2 /*--------------------------------------------------------------------*/
3 /*--- Linux-specific syscalls, etc. syswrap-linux.c ---*/
4 /*--------------------------------------------------------------------*/
7 This file is part of Valgrind, a dynamic binary instrumentation
10 Copyright (C) 2000-2010 Nicholas Nethercote
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.
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.
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
28 The GNU General Public License is contained in the file COPYING.
31 #if defined(VGO_linux)
33 #include "pub_core_basics.h"
34 #include "pub_core_vki.h"
35 #include "pub_core_vkiscnums.h"
36 #include "pub_core_threadstate.h"
37 #include "pub_core_aspacemgr.h"
38 #include "pub_core_debuginfo.h" // VG_(di_notify_*)
39 #include "pub_core_transtab.h" // VG_(discard_translations)
40 #include "pub_core_xarray.h"
41 #include "pub_core_clientstate.h"
42 #include "pub_core_debuglog.h"
43 #include "pub_core_libcbase.h"
44 #include "pub_core_libcassert.h"
45 #include "pub_core_libcfile.h"
46 #include "pub_core_libcprint.h"
47 #include "pub_core_libcproc.h"
48 #include "pub_core_libcsignal.h"
49 #include "pub_core_mallocfree.h"
50 #include "pub_core_tooliface.h"
51 #include "pub_core_options.h"
52 #include "pub_core_scheduler.h"
53 #include "pub_core_signals.h"
54 #include "pub_core_syscall.h"
55 #include "pub_core_syswrap.h"
57 #include "priv_types_n_macros.h"
58 #include "priv_syswrap-generic.h"
59 #include "priv_syswrap-linux.h"
62 // Run a thread from beginning to end and return the thread's
63 // scheduler-return-code.
64 static VgSchedReturnCode thread_wrapper(Word /*ThreadId*/ tidW)
66 VgSchedReturnCode ret;
67 ThreadId tid = (ThreadId)tidW;
68 ThreadState* tst = VG_(get_ThreadState)(tid);
70 VG_(debugLog)(1, "syswrap-linux",
71 "thread_wrapper(tid=%lld): entry\n",
74 vg_assert(tst->status == VgTs_Init);
76 /* make sure we get the CPU lock before doing anything significant */
77 VG_(acquire_BigLock)(tid, "thread_wrapper(starting new thread)");
80 VG_(printf)("thread tid %d started: stack = %p\n",
83 VG_TRACK(pre_thread_first_insn, tid);
85 tst->os_state.lwpid = VG_(gettid)();
86 /* Set the threadgroup for real. This overwrites the provisional
87 value set in do_clone() syswrap-*-linux.c. See comments in
88 do_clone for background, also #226116. */
89 tst->os_state.threadgroup = VG_(getpid)();
91 /* Thread created with all signals blocked; scheduler will set the
94 ret = VG_(scheduler)(tid);
96 vg_assert(VG_(is_exiting)(tid));
98 vg_assert(tst->status == VgTs_Runnable);
99 vg_assert(VG_(is_running_thread)(tid));
101 VG_(debugLog)(1, "syswrap-linux",
102 "thread_wrapper(tid=%lld): exit\n",
105 /* Return to caller, still holding the lock. */
110 /* ---------------------------------------------------------------------
112 ------------------------------------------------------------------ */
114 /* Run a thread all the way to the end, then do appropriate exit actions
115 (this is the last-one-out-turn-off-the-lights bit). */
116 static void run_a_thread_NORETURN ( Word tidW )
118 ThreadId tid = (ThreadId)tidW;
119 VgSchedReturnCode src;
122 VG_(debugLog)(1, "syswrap-linux",
123 "run_a_thread_NORETURN(tid=%lld): pre-thread_wrapper\n",
126 /* Run the thread all the way through. */
127 src = thread_wrapper(tid);
129 VG_(debugLog)(1, "syswrap-linux",
130 "run_a_thread_NORETURN(tid=%lld): post-thread_wrapper\n",
133 c = VG_(count_living_threads)();
134 vg_assert(c >= 1); /* stay sane */
136 // Tell the tool this thread is exiting
137 VG_TRACK( pre_thread_ll_exit, tid );
141 VG_(debugLog)(1, "syswrap-linux",
142 "run_a_thread_NORETURN(tid=%lld): "
143 "last one standing\n",
146 /* We are the last one standing. Keep hold of the lock and
147 carry on to show final tool results, then exit the entire system.
148 Use the continuation pointer set at startup in m_main. */
149 ( * VG_(address_of_m_main_shutdown_actions_NORETURN) ) (tid, src);
155 VG_(debugLog)(1, "syswrap-linux",
156 "run_a_thread_NORETURN(tid=%lld): "
157 "not last one standing\n",
160 /* OK, thread is dead, but others still exist. Just exit. */
161 tst = VG_(get_ThreadState)(tid);
163 /* This releases the run lock */
164 VG_(exit_thread)(tid);
165 vg_assert(tst->status == VgTs_Zombie);
167 /* We have to use this sequence to terminate the thread to
168 prevent a subtle race. If VG_(exit_thread)() had left the
169 ThreadState as Empty, then it could have been reallocated,
170 reusing the stack while we're doing these last cleanups.
171 Instead, VG_(exit_thread) leaves it as Zombie to prevent
172 reallocation. We need to make sure we don't touch the stack
173 between marking it Empty and exiting. Hence the
175 #if defined(VGP_x86_linux)
177 "movl %1, %0\n" /* set tst->status = VgTs_Empty */
178 "movl %2, %%eax\n" /* set %eax = __NR_exit */
179 "movl %3, %%ebx\n" /* set %ebx = tst->os_state.exitcode */
180 "int $0x80\n" /* exit(tst->os_state.exitcode) */
182 : "n" (VgTs_Empty), "n" (__NR_exit), "m" (tst->os_state.exitcode));
183 #elif defined(VGP_amd64_linux)
185 "movl %1, %0\n" /* set tst->status = VgTs_Empty */
186 "movq %2, %%rax\n" /* set %rax = __NR_exit */
187 "movq %3, %%rdi\n" /* set %rdi = tst->os_state.exitcode */
188 "syscall\n" /* exit(tst->os_state.exitcode) */
190 : "n" (VgTs_Empty), "n" (__NR_exit), "m" (tst->os_state.exitcode));
191 #elif defined(VGP_ppc32_linux) || defined(VGP_ppc64_linux)
192 { UInt vgts_empty = (UInt)VgTs_Empty;
194 "stw %1,%0\n\t" /* set tst->status = VgTs_Empty */
195 "li 0,%2\n\t" /* set r0 = __NR_exit */
196 "lwz 3,%3\n\t" /* set r3 = tst->os_state.exitcode */
197 "sc\n\t" /* exit(tst->os_state.exitcode) */
199 : "r" (vgts_empty), "n" (__NR_exit), "m" (tst->os_state.exitcode));
201 #elif defined(VGP_arm_linux)
203 "str %1, %0\n" /* set tst->status = VgTs_Empty */
204 "mov r7, %2\n" /* set %r7 = __NR_exit */
205 "ldr r0, %3\n" /* set %r0 = tst->os_state.exitcode */
206 "svc 0x00000000\n" /* exit(tst->os_state.exitcode) */
208 : "r" (VgTs_Empty), "n" (__NR_exit), "m" (tst->os_state.exitcode));
210 # error Unknown platform
213 VG_(core_panic)("Thread exit failed?\n");
220 Word ML_(start_thread_NORETURN) ( void* arg )
222 ThreadState* tst = (ThreadState*)arg;
223 ThreadId tid = tst->tid;
225 run_a_thread_NORETURN ( (Word)tid );
230 /* Allocate a stack for this thread, if it doesn't already have one.
231 They're allocated lazily, and never freed. Returns the initial stack
232 pointer value to use, or 0 if allocation failed. */
233 Addr ML_(allocstack)(ThreadId tid)
235 ThreadState* tst = VG_(get_ThreadState)(tid);
239 /* Either the stack_base and stack_init_SP are both zero (in which
240 case a stack hasn't been allocated) or they are both non-zero,
241 in which case it has. */
243 if (tst->os_state.valgrind_stack_base == 0)
244 vg_assert(tst->os_state.valgrind_stack_init_SP == 0);
246 if (tst->os_state.valgrind_stack_base != 0)
247 vg_assert(tst->os_state.valgrind_stack_init_SP != 0);
249 /* If no stack is present, allocate one. */
251 if (tst->os_state.valgrind_stack_base == 0) {
252 stack = VG_(am_alloc_VgStack)( &initial_SP );
254 tst->os_state.valgrind_stack_base = (Addr)stack;
255 tst->os_state.valgrind_stack_init_SP = initial_SP;
260 VG_(printf)( "stack for tid %d at %p; init_SP=%p\n",
262 (void*)tst->os_state.valgrind_stack_base,
263 (void*)tst->os_state.valgrind_stack_init_SP );
265 return tst->os_state.valgrind_stack_init_SP;
268 /* Allocate a stack for the main thread, and run it all the way to the
269 end. Although we already have a working VgStack
270 (VG_(interim_stack)) it's better to allocate a new one, so that
271 overflow detection works uniformly for all threads.
273 void VG_(main_thread_wrapper_NORETURN)(ThreadId tid)
276 VG_(debugLog)(1, "syswrap-linux",
277 "entering VG_(main_thread_wrapper_NORETURN)\n");
279 sp = ML_(allocstack)(tid);
281 #if defined(VGP_ppc32_linux)
282 /* make a stack frame */
286 #elif defined(VGP_ppc64_linux)
287 /* make a stack frame */
293 /* If we can't even allocate the first thread's stack, we're hosed.
295 vg_assert2(sp != 0, "Cannot allocate main thread's stack.");
297 /* shouldn't be any other threads around yet */
298 vg_assert( VG_(count_living_threads)() == 1 );
300 ML_(call_on_new_stack_0_1)(
301 (Addr)sp, /* stack */
302 0, /* bogus return address */
303 run_a_thread_NORETURN, /* fn to call */
304 (Word)tid /* arg to give it */
312 /* Do a clone which is really a fork() */
313 SysRes ML_(do_fork_clone) ( ThreadId tid, UInt flags,
314 Int* parent_tidptr, Int* child_tidptr )
316 vki_sigset_t fork_saved_mask;
320 if (flags & (VKI_CLONE_SETTLS | VKI_CLONE_FS | VKI_CLONE_VM
321 | VKI_CLONE_FILES | VKI_CLONE_VFORK))
322 return VG_(mk_SysRes_Error)( VKI_EINVAL );
324 /* Block all signals during fork, so that we can fix things up in
325 the child without being interrupted. */
326 VG_(sigfillset)(&mask);
327 VG_(sigprocmask)(VKI_SIG_SETMASK, &mask, &fork_saved_mask);
329 VG_(do_atfork_pre)(tid);
331 /* Since this is the fork() form of clone, we don't need all that
333 #if defined(VGP_x86_linux) \
334 || defined(VGP_ppc32_linux) || defined(VGP_ppc64_linux) \
335 || defined(VGP_arm_linux)
336 res = VG_(do_syscall5)( __NR_clone, flags,
337 (UWord)NULL, (UWord)parent_tidptr,
338 (UWord)NULL, (UWord)child_tidptr );
339 #elif defined(VGP_amd64_linux)
340 /* note that the last two arguments are the opposite way round to x86 and
341 ppc32 as the amd64 kernel expects the arguments in a different order */
342 res = VG_(do_syscall5)( __NR_clone, flags,
343 (UWord)NULL, (UWord)parent_tidptr,
344 (UWord)child_tidptr, (UWord)NULL );
346 # error Unknown platform
349 if (!sr_isError(res) && sr_Res(res) == 0) {
351 VG_(do_atfork_child)(tid);
353 /* restore signal mask */
354 VG_(sigprocmask)(VKI_SIG_SETMASK, &fork_saved_mask, NULL);
356 /* If --child-silent-after-fork=yes was specified, set the
357 output file descriptors to 'impossible' values. This is
358 noticed by send_bytes_to_logging_sink in m_libcprint.c, which
359 duly stops writing any further output. */
360 if (VG_(clo_child_silent_after_fork)) {
361 if (!VG_(log_output_sink).is_socket)
362 VG_(log_output_sink).fd = -1;
363 if (!VG_(xml_output_sink).is_socket)
364 VG_(xml_output_sink).fd = -1;
368 if (!sr_isError(res) && sr_Res(res) > 0) {
370 VG_(do_atfork_parent)(tid);
372 if (VG_(clo_trace_syscalls))
373 VG_(printf)(" clone(fork): process %d created child %ld\n",
374 VG_(getpid)(), sr_Res(res));
376 /* restore signal mask */
377 VG_(sigprocmask)(VKI_SIG_SETMASK, &fork_saved_mask, NULL);
384 /* ---------------------------------------------------------------------
385 PRE/POST wrappers for arch-generic, Linux-specific syscalls
386 ------------------------------------------------------------------ */
388 // Nb: See the comment above the generic PRE/POST wrappers in
389 // m_syswrap/syswrap-generic.c for notes about how they work.
391 #define PRE(name) DEFN_PRE_TEMPLATE(linux, name)
392 #define POST(name) DEFN_POST_TEMPLATE(linux, name)
394 // Macros to support 64-bit syscall args split into two 32 bit values
395 #define LOHI64(lo,hi) ( ((ULong)(lo)) | (((ULong)(hi)) << 32) )
396 #if defined(VG_LITTLEENDIAN)
397 #define MERGE64(lo,hi) ( ((ULong)(lo)) | (((ULong)(hi)) << 32) )
398 #define MERGE64_FIRST(name) name##_low
399 #define MERGE64_SECOND(name) name##_high
400 #elif defined(VG_BIGENDIAN)
401 #define MERGE64(hi,lo) ( ((ULong)(lo)) | (((ULong)(hi)) << 32) )
402 #define MERGE64_FIRST(name) name##_high
403 #define MERGE64_SECOND(name) name##_low
405 #error Unknown endianness
408 /* ---------------------------------------------------------------------
410 ------------------------------------------------------------------ */
414 // Nb: depending on 'flags', the 'type' and 'data' args may be ignored.
415 // We are conservative and check everything, except the memory pointed to
417 *flags |= SfMayBlock;
418 PRINT("sys_mount( %#lx(%s), %#lx(%s), %#lx(%s), %#lx, %#lx )",
419 ARG1,(Char*)ARG1, ARG2,(Char*)ARG2, ARG3,(Char*)ARG3, ARG4, ARG5);
420 PRE_REG_READ5(long, "mount",
421 char *, source, char *, target, char *, type,
422 unsigned long, flags, void *, data);
423 PRE_MEM_RASCIIZ( "mount(source)", ARG1);
424 PRE_MEM_RASCIIZ( "mount(target)", ARG2);
425 PRE_MEM_RASCIIZ( "mount(type)", ARG3);
430 PRINT("sys_oldumount( %#lx )", ARG1);
431 PRE_REG_READ1(long, "umount", char *, path);
432 PRE_MEM_RASCIIZ( "umount(path)", ARG1);
437 PRINT("sys_umount( %#lx, %ld )", ARG1, ARG2);
438 PRE_REG_READ2(long, "umount2", char *, path, int, flags);
439 PRE_MEM_RASCIIZ( "umount2(path)", ARG1);
442 /* ---------------------------------------------------------------------
443 16- and 32-bit uid/gid wrappers
444 ------------------------------------------------------------------ */
448 PRINT("sys_setfsuid16 ( %ld )", ARG1);
449 PRE_REG_READ1(long, "setfsuid16", vki_old_uid_t, uid);
454 PRINT("sys_setfsuid ( %ld )", ARG1);
455 PRE_REG_READ1(long, "setfsuid", vki_uid_t, uid);
460 PRINT("sys_setfsgid16 ( %ld )", ARG1);
461 PRE_REG_READ1(long, "setfsgid16", vki_old_gid_t, gid);
466 PRINT("sys_setfsgid ( %ld )", ARG1);
467 PRE_REG_READ1(long, "setfsgid", vki_gid_t, gid);
472 PRINT("sys_setresuid16 ( %ld, %ld, %ld )", ARG1, ARG2, ARG3);
473 PRE_REG_READ3(long, "setresuid16",
474 vki_old_uid_t, ruid, vki_old_uid_t, euid, vki_old_uid_t, suid);
479 PRINT("sys_setresuid ( %ld, %ld, %ld )", ARG1, ARG2, ARG3);
480 PRE_REG_READ3(long, "setresuid",
481 vki_uid_t, ruid, vki_uid_t, euid, vki_uid_t, suid);
486 PRINT("sys_getresuid16 ( %#lx, %#lx, %#lx )", ARG1,ARG2,ARG3);
487 PRE_REG_READ3(long, "getresuid16",
488 vki_old_uid_t *, ruid, vki_old_uid_t *, euid,
489 vki_old_uid_t *, suid);
490 PRE_MEM_WRITE( "getresuid16(ruid)", ARG1, sizeof(vki_old_uid_t) );
491 PRE_MEM_WRITE( "getresuid16(euid)", ARG2, sizeof(vki_old_uid_t) );
492 PRE_MEM_WRITE( "getresuid16(suid)", ARG3, sizeof(vki_old_uid_t) );
494 POST(sys_getresuid16)
498 POST_MEM_WRITE( ARG1, sizeof(vki_old_uid_t) );
499 POST_MEM_WRITE( ARG2, sizeof(vki_old_uid_t) );
500 POST_MEM_WRITE( ARG3, sizeof(vki_old_uid_t) );
506 PRINT("sys_getresuid ( %#lx, %#lx, %#lx )", ARG1,ARG2,ARG3);
507 PRE_REG_READ3(long, "getresuid",
508 vki_uid_t *, ruid, vki_uid_t *, euid, vki_uid_t *, suid);
509 PRE_MEM_WRITE( "getresuid(ruid)", ARG1, sizeof(vki_uid_t) );
510 PRE_MEM_WRITE( "getresuid(euid)", ARG2, sizeof(vki_uid_t) );
511 PRE_MEM_WRITE( "getresuid(suid)", ARG3, sizeof(vki_uid_t) );
517 POST_MEM_WRITE( ARG1, sizeof(vki_uid_t) );
518 POST_MEM_WRITE( ARG2, sizeof(vki_uid_t) );
519 POST_MEM_WRITE( ARG3, sizeof(vki_uid_t) );
525 PRINT("sys_setresgid16 ( %ld, %ld, %ld )", ARG1, ARG2, ARG3);
526 PRE_REG_READ3(long, "setresgid16",
528 vki_old_gid_t, egid, vki_old_gid_t, sgid);
533 PRINT("sys_setresgid ( %ld, %ld, %ld )", ARG1, ARG2, ARG3);
534 PRE_REG_READ3(long, "setresgid",
535 vki_gid_t, rgid, vki_gid_t, egid, vki_gid_t, sgid);
540 PRINT("sys_getresgid16 ( %#lx, %#lx, %#lx )", ARG1,ARG2,ARG3);
541 PRE_REG_READ3(long, "getresgid16",
542 vki_old_gid_t *, rgid, vki_old_gid_t *, egid,
543 vki_old_gid_t *, sgid);
544 PRE_MEM_WRITE( "getresgid16(rgid)", ARG1, sizeof(vki_old_gid_t) );
545 PRE_MEM_WRITE( "getresgid16(egid)", ARG2, sizeof(vki_old_gid_t) );
546 PRE_MEM_WRITE( "getresgid16(sgid)", ARG3, sizeof(vki_old_gid_t) );
548 POST(sys_getresgid16)
552 POST_MEM_WRITE( ARG1, sizeof(vki_old_gid_t) );
553 POST_MEM_WRITE( ARG2, sizeof(vki_old_gid_t) );
554 POST_MEM_WRITE( ARG3, sizeof(vki_old_gid_t) );
560 PRINT("sys_getresgid ( %#lx, %#lx, %#lx )", ARG1,ARG2,ARG3);
561 PRE_REG_READ3(long, "getresgid",
562 vki_gid_t *, rgid, vki_gid_t *, egid, vki_gid_t *, sgid);
563 PRE_MEM_WRITE( "getresgid(rgid)", ARG1, sizeof(vki_gid_t) );
564 PRE_MEM_WRITE( "getresgid(egid)", ARG2, sizeof(vki_gid_t) );
565 PRE_MEM_WRITE( "getresgid(sgid)", ARG3, sizeof(vki_gid_t) );
571 POST_MEM_WRITE( ARG1, sizeof(vki_gid_t) );
572 POST_MEM_WRITE( ARG2, sizeof(vki_gid_t) );
573 POST_MEM_WRITE( ARG3, sizeof(vki_gid_t) );
577 /* ---------------------------------------------------------------------
578 miscellaneous wrappers
579 ------------------------------------------------------------------ */
586 PRINT("exit_group( %ld )", ARG1);
587 PRE_REG_READ1(void, "exit_group", int, status);
589 tst = VG_(get_ThreadState)(tid);
591 /* A little complex; find all the threads with the same threadgroup
592 as this one (including this one), and mark them to exit */
593 for (t = 1; t < VG_N_THREADS; t++) {
595 VG_(threads)[t].status == VgTs_Empty
598 VG_(threads)[t].os_state.threadgroup != tst->os_state.threadgroup
602 VG_(threads)[t].exitreason = VgSrc_ExitThread;
603 VG_(threads)[t].os_state.exitcode = ARG1;
606 VG_(get_thread_out_of_syscall)(t); /* unblock it, if blocked */
609 /* We have to claim the syscall already succeeded. */
610 SET_STATUS_Success(0);
615 PRINT("sys_llseek ( %ld, 0x%lx, 0x%lx, %#lx, %ld )", ARG1,ARG2,ARG3,ARG4,ARG5);
616 PRE_REG_READ5(long, "llseek",
617 unsigned int, fd, unsigned long, offset_high,
618 unsigned long, offset_low, vki_loff_t *, result,
619 unsigned int, whence);
620 if (!ML_(fd_allowed)(ARG1, "llseek", tid, False))
621 SET_STATUS_Failure( VKI_EBADF );
623 PRE_MEM_WRITE( "llseek(result)", ARG4, sizeof(vki_loff_t));
629 POST_MEM_WRITE( ARG4, sizeof(vki_loff_t) );
634 struct vki_timex *tx = (struct vki_timex *)ARG1;
635 PRINT("sys_adjtimex ( %#lx )", ARG1);
636 PRE_REG_READ1(long, "adjtimex", struct timex *, buf);
637 PRE_MEM_READ( "adjtimex(timex->modes)", ARG1, sizeof(tx->modes));
639 #define ADJX(bits,field) \
640 if (tx->modes & (bits)) \
641 PRE_MEM_READ( "adjtimex(timex->"#field")", \
642 (Addr)&tx->field, sizeof(tx->field))
644 if (tx->modes & VKI_ADJ_ADJTIME) {
645 if (!(tx->modes & VKI_ADJ_OFFSET_READONLY))
646 PRE_MEM_READ( "adjtimex(timex->offset)", (Addr)&tx->offset, sizeof(tx->offset));
648 ADJX(VKI_ADJ_OFFSET, offset);
649 ADJX(VKI_ADJ_FREQUENCY, freq);
650 ADJX(VKI_ADJ_MAXERROR, maxerror);
651 ADJX(VKI_ADJ_ESTERROR, esterror);
652 ADJX(VKI_ADJ_STATUS, status);
653 ADJX(VKI_ADJ_TIMECONST|VKI_ADJ_TAI, constant);
654 ADJX(VKI_ADJ_TICK, tick);
658 PRE_MEM_WRITE( "adjtimex(timex)", ARG1, sizeof(struct vki_timex));
663 POST_MEM_WRITE( ARG1, sizeof(struct vki_timex) );
668 PRINT("sys_ioperm ( %ld, %ld, %ld )", ARG1, ARG2, ARG3 );
669 PRE_REG_READ3(long, "ioperm",
670 unsigned long, from, unsigned long, num, int, turn_on);
675 *flags |= SfMayBlock;
676 PRINT("sys_syslog (%ld, %#lx, %ld)", ARG1,ARG2,ARG3);
677 PRE_REG_READ3(long, "syslog", int, type, char *, bufp, int, len);
679 // The kernel uses magic numbers here, rather than named constants,
680 // therefore so do we.
681 case 2: case 3: case 4:
682 PRE_MEM_WRITE( "syslog(bufp)", ARG2, ARG3);
691 case 2: case 3: case 4:
692 POST_MEM_WRITE( ARG2, ARG3 );
701 PRINT("sys_vhangup ( )");
702 PRE_REG_READ0(long, "vhangup");
707 PRINT("sys_sysinfo ( %#lx )",ARG1);
708 PRE_REG_READ1(long, "sysinfo", struct sysinfo *, info);
709 PRE_MEM_WRITE( "sysinfo(info)", ARG1, sizeof(struct vki_sysinfo) );
713 POST_MEM_WRITE( ARG1, sizeof(struct vki_sysinfo) );
718 PRINT("sys_personality ( %llu )", (ULong)ARG1);
719 PRE_REG_READ1(long, "personality", vki_u_long, persona);
724 struct __vki_sysctl_args *args;
725 PRINT("sys_sysctl ( %#lx )", ARG1 );
726 args = (struct __vki_sysctl_args *)ARG1;
727 PRE_REG_READ1(long, "sysctl", struct __sysctl_args *, args);
728 PRE_MEM_WRITE( "sysctl(args)", ARG1, sizeof(struct __vki_sysctl_args) );
729 if (!VG_(am_is_valid_for_client)(ARG1, sizeof(struct __vki_sysctl_args),
731 SET_STATUS_Failure( VKI_EFAULT );
735 PRE_MEM_READ("sysctl(name)", (Addr)args->name, args->nlen * sizeof(*args->name));
736 if (args->newval != NULL)
737 PRE_MEM_READ("sysctl(newval)", (Addr)args->newval, args->newlen);
738 if (args->oldlenp != NULL) {
739 PRE_MEM_READ("sysctl(oldlenp)", (Addr)args->oldlenp, sizeof(*args->oldlenp));
740 PRE_MEM_WRITE("sysctl(oldval)", (Addr)args->oldval, *args->oldlenp);
745 struct __vki_sysctl_args *args;
746 args = (struct __vki_sysctl_args *)ARG1;
747 if (args->oldlenp != NULL) {
748 POST_MEM_WRITE((Addr)args->oldlenp, sizeof(*args->oldlenp));
749 POST_MEM_WRITE((Addr)args->oldval, 1 + *args->oldlenp);
755 *flags |= SfMayBlock;
756 PRINT( "sys_prctl ( %ld, %ld, %ld, %ld, %ld )", ARG1, ARG2, ARG3, ARG4, ARG5 );
758 case VKI_PR_SET_PDEATHSIG:
759 PRE_REG_READ2(int, "prctl", int, option, int, signal);
761 case VKI_PR_GET_PDEATHSIG:
762 PRE_REG_READ2(int, "prctl", int, option, int *, signal);
763 PRE_MEM_WRITE("prctl(get-death-signal)", ARG2, sizeof(Int));
765 case VKI_PR_GET_DUMPABLE:
766 PRE_REG_READ1(int, "prctl", int, option);
768 case VKI_PR_SET_DUMPABLE:
769 PRE_REG_READ2(int, "prctl", int, option, int, dump);
771 case VKI_PR_GET_UNALIGN:
772 PRE_REG_READ2(int, "prctl", int, option, int *, value);
773 PRE_MEM_WRITE("prctl(get-unalign)", ARG2, sizeof(Int));
775 case VKI_PR_SET_UNALIGN:
776 PRE_REG_READ2(int, "prctl", int, option, int, value);
778 case VKI_PR_GET_KEEPCAPS:
779 PRE_REG_READ1(int, "prctl", int, option);
781 case VKI_PR_SET_KEEPCAPS:
782 PRE_REG_READ2(int, "prctl", int, option, int, keepcaps);
784 case VKI_PR_GET_FPEMU:
785 PRE_REG_READ2(int, "prctl", int, option, int *, value);
786 PRE_MEM_WRITE("prctl(get-fpemu)", ARG2, sizeof(Int));
788 case VKI_PR_SET_FPEMU:
789 PRE_REG_READ2(int, "prctl", int, option, int, value);
791 case VKI_PR_GET_FPEXC:
792 PRE_REG_READ2(int, "prctl", int, option, int *, value);
793 PRE_MEM_WRITE("prctl(get-fpexc)", ARG2, sizeof(Int));
795 case VKI_PR_SET_FPEXC:
796 PRE_REG_READ2(int, "prctl", int, option, int, value);
798 case VKI_PR_GET_TIMING:
799 PRE_REG_READ1(int, "prctl", int, option);
801 case VKI_PR_SET_TIMING:
802 PRE_REG_READ2(int, "prctl", int, option, int, timing);
804 case VKI_PR_SET_NAME:
805 PRE_REG_READ2(int, "prctl", int, option, char *, name);
806 PRE_MEM_RASCIIZ("prctl(set-name)", ARG2);
808 case VKI_PR_GET_NAME:
809 PRE_REG_READ2(int, "prctl", int, option, char *, name);
810 PRE_MEM_WRITE("prctl(get-name)", ARG2, VKI_TASK_COMM_LEN);
812 case VKI_PR_GET_ENDIAN:
813 PRE_REG_READ2(int, "prctl", int, option, int *, value);
814 PRE_MEM_WRITE("prctl(get-endian)", ARG2, sizeof(Int));
816 case VKI_PR_SET_ENDIAN:
817 PRE_REG_READ2(int, "prctl", int, option, int, value);
820 PRE_REG_READ5(long, "prctl",
821 int, option, unsigned long, arg2, unsigned long, arg3,
822 unsigned long, arg4, unsigned long, arg5);
829 case VKI_PR_GET_PDEATHSIG:
830 POST_MEM_WRITE(ARG2, sizeof(Int));
832 case VKI_PR_GET_UNALIGN:
833 POST_MEM_WRITE(ARG2, sizeof(Int));
835 case VKI_PR_GET_FPEMU:
836 POST_MEM_WRITE(ARG2, sizeof(Int));
838 case VKI_PR_GET_FPEXC:
839 POST_MEM_WRITE(ARG2, sizeof(Int));
841 case VKI_PR_GET_NAME:
842 POST_MEM_WRITE(ARG2, VKI_TASK_COMM_LEN);
844 case VKI_PR_GET_ENDIAN:
845 POST_MEM_WRITE(ARG2, sizeof(Int));
852 *flags |= SfMayBlock;
853 PRINT("sys_sendfile ( %ld, %ld, %#lx, %lu )", ARG1,ARG2,ARG3,ARG4);
854 PRE_REG_READ4(ssize_t, "sendfile",
855 int, out_fd, int, in_fd, vki_off_t *, offset,
858 PRE_MEM_WRITE( "sendfile(offset)", ARG3, sizeof(vki_off_t) );
863 POST_MEM_WRITE( ARG3, sizeof( vki_off_t ) );
869 *flags |= SfMayBlock;
870 PRINT("sendfile64 ( %ld, %ld, %#lx, %lu )",ARG1,ARG2,ARG3,ARG4);
871 PRE_REG_READ4(ssize_t, "sendfile64",
872 int, out_fd, int, in_fd, vki_loff_t *, offset,
875 PRE_MEM_WRITE( "sendfile64(offset)", ARG3, sizeof(vki_loff_t) );
880 POST_MEM_WRITE( ARG3, sizeof(vki_loff_t) );
887 arg param used by ops
889 ARG1 - u32 *futex all
891 ARG3 - int val WAIT,WAKE,FD,REQUEUE,CMP_REQUEUE
892 ARG4 - struct timespec *utime WAIT:time* REQUEUE,CMP_REQUEUE:val2
893 ARG5 - u32 *uaddr2 REQUEUE,CMP_REQUEUE
894 ARG6 - int val3 CMP_REQUEUE
896 PRINT("sys_futex ( %#lx, %ld, %ld, %#lx, %#lx )", ARG1,ARG2,ARG3,ARG4,ARG5);
897 switch(ARG2 & ~(VKI_FUTEX_PRIVATE_FLAG|VKI_FUTEX_CLOCK_REALTIME)) {
898 case VKI_FUTEX_CMP_REQUEUE:
899 case VKI_FUTEX_WAKE_OP:
900 case VKI_FUTEX_CMP_REQUEUE_PI:
901 PRE_REG_READ6(long, "futex",
902 vki_u32 *, futex, int, op, int, val,
903 struct timespec *, utime, vki_u32 *, uaddr2, int, val3);
905 case VKI_FUTEX_REQUEUE:
906 case VKI_FUTEX_WAIT_REQUEUE_PI:
907 PRE_REG_READ5(long, "futex",
908 vki_u32 *, futex, int, op, int, val,
909 struct timespec *, utime, vki_u32 *, uaddr2);
911 case VKI_FUTEX_WAIT_BITSET:
912 PRE_REG_READ6(long, "futex",
913 vki_u32 *, futex, int, op, int, val,
914 struct timespec *, utime, int, dummy, int, val3);
916 case VKI_FUTEX_WAKE_BITSET:
917 PRE_REG_READ6(long, "futex",
918 vki_u32 *, futex, int, op, int, val,
919 int, dummy, int, dummy2, int, val3);
922 case VKI_FUTEX_LOCK_PI:
923 PRE_REG_READ4(long, "futex",
924 vki_u32 *, futex, int, op, int, val,
925 struct timespec *, utime);
929 case VKI_FUTEX_TRYLOCK_PI:
930 PRE_REG_READ3(long, "futex",
931 vki_u32 *, futex, int, op, int, val);
933 case VKI_FUTEX_UNLOCK_PI:
935 PRE_REG_READ2(long, "futex", vki_u32 *, futex, int, op);
939 *flags |= SfMayBlock;
941 switch(ARG2 & ~(VKI_FUTEX_PRIVATE_FLAG|VKI_FUTEX_CLOCK_REALTIME)) {
943 case VKI_FUTEX_LOCK_PI:
944 case VKI_FUTEX_WAIT_BITSET:
945 case VKI_FUTEX_WAIT_REQUEUE_PI:
946 PRE_MEM_READ( "futex(futex)", ARG1, sizeof(Int) );
948 PRE_MEM_READ( "futex(timeout)", ARG4, sizeof(struct vki_timespec) );
951 case VKI_FUTEX_REQUEUE:
952 case VKI_FUTEX_CMP_REQUEUE:
953 case VKI_FUTEX_CMP_REQUEUE_PI:
954 case VKI_FUTEX_WAKE_OP:
955 PRE_MEM_READ( "futex(futex)", ARG1, sizeof(Int) );
956 PRE_MEM_READ( "futex(futex2)", ARG5, sizeof(Int) );
960 case VKI_FUTEX_TRYLOCK_PI:
961 case VKI_FUTEX_UNLOCK_PI:
962 PRE_MEM_READ( "futex(futex)", ARG1, sizeof(Int) );
966 case VKI_FUTEX_WAKE_BITSET:
967 /* no additional pointers */
971 SET_STATUS_Failure( VKI_ENOSYS ); // some futex function we don't understand
978 POST_MEM_WRITE( ARG1, sizeof(int) );
979 if (ARG2 == VKI_FUTEX_FD) {
980 if (!ML_(fd_allowed)(RES, "futex", tid, True)) {
982 SET_STATUS_Failure( VKI_EMFILE );
984 if (VG_(clo_track_fds))
985 ML_(record_fd_open_nameless)(tid, RES);
990 PRE(sys_set_robust_list)
992 PRINT("sys_set_robust_list ( %#lx, %ld )", ARG1,ARG2);
993 PRE_REG_READ2(long, "set_robust_list",
994 struct vki_robust_list_head *, head, vki_size_t, len);
996 /* Just check the robust_list_head structure is readable - don't
997 try and chase the list as the kernel will only read it when
998 the thread exits so the current contents is irrelevant. */
1000 PRE_MEM_READ("set_robust_list(head)", ARG1, ARG2);
1003 PRE(sys_get_robust_list)
1005 PRINT("sys_get_robust_list ( %ld, %#lx, %ld )", ARG1,ARG2,ARG3);
1006 PRE_REG_READ3(long, "get_robust_list",
1008 struct vki_robust_list_head **, head_ptr,
1009 vki_size_t *, len_ptr);
1010 PRE_MEM_WRITE("get_robust_list(head_ptr)",
1011 ARG2, sizeof(struct vki_robust_list_head *));
1012 PRE_MEM_WRITE("get_robust_list(len_ptr)",
1013 ARG3, sizeof(struct vki_size_t *));
1015 POST(sys_get_robust_list)
1017 POST_MEM_WRITE(ARG2, sizeof(struct vki_robust_list_head *));
1018 POST_MEM_WRITE(ARG3, sizeof(struct vki_size_t *));
1023 *flags |= SfMayBlock;
1024 PRINT("sys_pselect6 ( %ld, %#lx, %#lx, %#lx, %#lx, %#lx )", ARG1,ARG2,ARG3,ARG4,ARG5,ARG6);
1025 PRE_REG_READ6(long, "pselect6",
1026 int, n, vki_fd_set *, readfds, vki_fd_set *, writefds,
1027 vki_fd_set *, exceptfds, struct vki_timeval *, timeout,
1029 // XXX: this possibly understates how much memory is read.
1031 PRE_MEM_READ( "pselect6(readfds)",
1032 ARG2, ARG1/8 /* __FD_SETSIZE/8 */ );
1034 PRE_MEM_READ( "pselect6(writefds)",
1035 ARG3, ARG1/8 /* __FD_SETSIZE/8 */ );
1037 PRE_MEM_READ( "pselect6(exceptfds)",
1038 ARG4, ARG1/8 /* __FD_SETSIZE/8 */ );
1040 PRE_MEM_READ( "pselect6(timeout)", ARG5, sizeof(struct vki_timeval) );
1042 PRE_MEM_READ( "pselect6(sig)", ARG6, sizeof(void *)+sizeof(vki_size_t) );
1048 struct vki_pollfd* ufds = (struct vki_pollfd *)ARG1;
1049 *flags |= SfMayBlock;
1050 PRINT("sys_ppoll ( %#lx, %ld, %#lx, %#lx, %llu )\n", ARG1,ARG2,ARG3,ARG4,(ULong)ARG5);
1051 PRE_REG_READ5(long, "ppoll",
1052 struct vki_pollfd *, ufds, unsigned int, nfds,
1053 struct vki_timespec *, tsp, vki_sigset_t *, sigmask,
1054 vki_size_t, sigsetsize);
1056 for (i = 0; i < ARG2; i++) {
1057 PRE_MEM_READ( "ppoll(ufds.fd)",
1058 (Addr)(&ufds[i].fd), sizeof(ufds[i].fd) );
1059 PRE_MEM_READ( "ppoll(ufds.events)",
1060 (Addr)(&ufds[i].events), sizeof(ufds[i].events) );
1061 PRE_MEM_WRITE( "ppoll(ufd.reventss)",
1062 (Addr)(&ufds[i].revents), sizeof(ufds[i].revents) );
1066 PRE_MEM_READ( "ppoll(tsp)", ARG3, sizeof(struct vki_timespec) );
1068 PRE_MEM_READ( "ppoll(sigmask)", ARG4, sizeof(vki_sigset_t) );
1075 struct vki_pollfd* ufds = (struct vki_pollfd *)ARG1;
1076 for (i = 0; i < ARG2; i++)
1077 POST_MEM_WRITE( (Addr)(&ufds[i].revents), sizeof(ufds[i].revents) );
1082 /* ---------------------------------------------------------------------
1084 ------------------------------------------------------------------ */
1086 PRE(sys_epoll_create)
1088 PRINT("sys_epoll_create ( %ld )", ARG1);
1089 PRE_REG_READ1(long, "epoll_create", int, size);
1091 POST(sys_epoll_create)
1094 if (!ML_(fd_allowed)(RES, "epoll_create", tid, True)) {
1096 SET_STATUS_Failure( VKI_EMFILE );
1098 if (VG_(clo_track_fds))
1099 ML_(record_fd_open_nameless) (tid, RES);
1103 PRE(sys_epoll_create1)
1105 PRINT("sys_epoll_create1 ( %ld )", ARG1);
1106 PRE_REG_READ1(long, "epoll_create1", int, flags);
1108 POST(sys_epoll_create1)
1111 if (!ML_(fd_allowed)(RES, "epoll_create1", tid, True)) {
1113 SET_STATUS_Failure( VKI_EMFILE );
1115 if (VG_(clo_track_fds))
1116 ML_(record_fd_open_nameless) (tid, RES);
1122 static const HChar* epoll_ctl_s[3] = {
1127 PRINT("sys_epoll_ctl ( %ld, %s, %ld, %#lx )",
1128 ARG1, ( ARG2<3 ? epoll_ctl_s[ARG2] : "?" ), ARG3, ARG4);
1129 PRE_REG_READ4(long, "epoll_ctl",
1130 int, epfd, int, op, int, fd, struct vki_epoll_event *, event);
1131 if (ARG2 != VKI_EPOLL_CTL_DEL)
1132 PRE_MEM_READ( "epoll_ctl(event)", ARG4, sizeof(struct vki_epoll_event) );
1137 *flags |= SfMayBlock;
1138 PRINT("sys_epoll_wait ( %ld, %#lx, %ld, %ld )", ARG1, ARG2, ARG3, ARG4);
1139 PRE_REG_READ4(long, "epoll_wait",
1140 int, epfd, struct vki_epoll_event *, events,
1141 int, maxevents, int, timeout);
1142 PRE_MEM_WRITE( "epoll_wait(events)", ARG2, sizeof(struct vki_epoll_event)*ARG3);
1144 POST(sys_epoll_wait)
1148 POST_MEM_WRITE( ARG2, sizeof(struct vki_epoll_event)*RES ) ;
1151 PRE(sys_epoll_pwait)
1153 *flags |= SfMayBlock;
1154 PRINT("sys_epoll_pwait ( %ld, %#lx, %ld, %ld, %#lx, %llu )", ARG1,ARG2,ARG3,ARG4,ARG5,(ULong)ARG6);
1155 PRE_REG_READ6(long, "epoll_pwait",
1156 int, epfd, struct vki_epoll_event *, events,
1157 int, maxevents, int, timeout, vki_sigset_t *, sigmask,
1158 vki_size_t, sigsetsize);
1159 PRE_MEM_WRITE( "epoll_pwait(events)", ARG2, sizeof(struct vki_epoll_event)*ARG3);
1161 PRE_MEM_READ( "epoll_pwait(sigmask)", ARG5, sizeof(vki_sigset_t) );
1163 POST(sys_epoll_pwait)
1167 POST_MEM_WRITE( ARG2, sizeof(struct vki_epoll_event)*RES ) ;
1172 PRINT("sys_eventfd ( %lu )", ARG1);
1173 PRE_REG_READ1(long, "sys_eventfd", unsigned int, count);
1177 if (!ML_(fd_allowed)(RES, "eventfd", tid, True)) {
1179 SET_STATUS_Failure( VKI_EMFILE );
1181 if (VG_(clo_track_fds))
1182 ML_(record_fd_open_nameless) (tid, RES);
1188 PRINT("sys_eventfd2 ( %lu, %ld )", ARG1,ARG2);
1189 PRE_REG_READ2(long, "sys_eventfd2", unsigned int, count, int, flags);
1193 if (!ML_(fd_allowed)(RES, "eventfd2", tid, True)) {
1195 SET_STATUS_Failure( VKI_EMFILE );
1197 if (VG_(clo_track_fds))
1198 ML_(record_fd_open_nameless) (tid, RES);
1204 *flags |= SfMayBlock;
1205 #if VG_WORDSIZE == 4
1206 PRINT("sys_fallocate ( %ld, %ld, %lld, %lld )",
1207 ARG1, ARG2, MERGE64(ARG3,ARG4), MERGE64(ARG5,ARG6));
1208 PRE_REG_READ6(long, "fallocate",
1210 unsigned, MERGE64_FIRST(offset), unsigned, MERGE64_SECOND(offset),
1211 unsigned, MERGE64_FIRST(len), unsigned, MERGE64_SECOND(len));
1212 #elif VG_WORDSIZE == 8
1213 PRINT("sys_fallocate ( %ld, %ld, %lld, %lld )",
1214 ARG1, ARG2, (Long)ARG3, (Long)ARG4);
1215 PRE_REG_READ4(long, "fallocate",
1216 int, fd, int, mode, vki_loff_t, offset, vki_loff_t, len);
1218 # error Unexpected word size
1220 if (!ML_(fd_allowed)(ARG1, "fallocate", tid, False))
1221 SET_STATUS_Failure( VKI_EBADF );
1224 /* ---------------------------------------------------------------------
1225 tid-related wrappers
1226 ------------------------------------------------------------------ */
1230 PRINT("sys_gettid ()");
1231 PRE_REG_READ0(long, "gettid");
1234 PRE(sys_set_tid_address)
1236 PRINT("sys_set_tid_address ( %#lx )", ARG1);
1237 PRE_REG_READ1(long, "set_tid_address", int *, tidptr);
1242 PRINT("sys_tgkill ( %ld, %ld )", ARG1,ARG2);
1243 PRE_REG_READ2(long, "tkill", int, tid, int, sig);
1244 if (!ML_(client_signal_OK)(ARG2)) {
1245 SET_STATUS_Failure( VKI_EINVAL );
1249 /* Check to see if this kill gave us a pending signal */
1250 *flags |= SfPollAfter;
1252 if (VG_(clo_trace_signals))
1253 VG_(message)(Vg_DebugMsg, "tkill: sending signal %ld to pid %ld\n",
1256 /* If we're sending SIGKILL, check to see if the target is one of
1257 our threads and handle it specially. */
1258 if (ARG2 == VKI_SIGKILL && ML_(do_sigkill)(ARG1, -1)) {
1259 SET_STATUS_Success(0);
1263 /* Ask to handle this syscall via the slow route, since that's the
1264 only one that sets tst->status to VgTs_WaitSys. If the result
1265 of doing the syscall is an immediate run of
1266 async_signalhandler() in m_signals, then we need the thread to
1267 be properly tidied away. I have the impression the previous
1268 version of this wrapper worked on x86/amd64 only because the
1269 kernel did not immediately deliver the async signal to this
1270 thread (on ppc it did, which broke the assertion re tst->status
1271 at the top of async_signalhandler()). */
1272 *flags |= SfMayBlock;
1276 if (VG_(clo_trace_signals))
1277 VG_(message)(Vg_DebugMsg, "tkill: sent signal %ld to pid %ld\n",
1283 PRINT("sys_tgkill ( %ld, %ld, %ld )", ARG1,ARG2,ARG3);
1284 PRE_REG_READ3(long, "tgkill", int, tgid, int, tid, int, sig);
1285 if (!ML_(client_signal_OK)(ARG3)) {
1286 SET_STATUS_Failure( VKI_EINVAL );
1290 /* Check to see if this kill gave us a pending signal */
1291 *flags |= SfPollAfter;
1293 if (VG_(clo_trace_signals))
1294 VG_(message)(Vg_DebugMsg,
1295 "tgkill: sending signal %ld to pid %ld/%ld\n",
1298 /* If we're sending SIGKILL, check to see if the target is one of
1299 our threads and handle it specially. */
1300 if (ARG3 == VKI_SIGKILL && ML_(do_sigkill)(ARG2, ARG1)) {
1301 SET_STATUS_Success(0);
1305 /* Ask to handle this syscall via the slow route, since that's the
1306 only one that sets tst->status to VgTs_WaitSys. If the result
1307 of doing the syscall is an immediate run of
1308 async_signalhandler() in m_signals, then we need the thread to
1309 be properly tidied away. I have the impression the previous
1310 version of this wrapper worked on x86/amd64 only because the
1311 kernel did not immediately deliver the async signal to this
1312 thread (on ppc it did, which broke the assertion re tst->status
1313 at the top of async_signalhandler()). */
1314 *flags |= SfMayBlock;
1318 if (VG_(clo_trace_signals))
1319 VG_(message)(Vg_DebugMsg,
1320 "tgkill: sent signal %ld to pid %ld/%ld\n",
1324 /* ---------------------------------------------------------------------
1326 ------------------------------------------------------------------ */
1330 PRINT("sys_fadvise64 ( %ld, %lld, %lu, %ld )",
1331 ARG1, MERGE64(ARG2,ARG3), ARG4, ARG5);
1332 PRE_REG_READ5(long, "fadvise64",
1333 int, fd, vki_u32, MERGE64_FIRST(offset), vki_u32, MERGE64_SECOND(offset),
1334 vki_size_t, len, int, advice);
1337 PRE(sys_fadvise64_64)
1339 PRINT("sys_fadvise64_64 ( %ld, %lld, %lld, %ld )",
1340 ARG1, MERGE64(ARG2,ARG3), MERGE64(ARG4,ARG5), ARG6);
1341 PRE_REG_READ6(long, "fadvise64_64",
1342 int, fd, vki_u32, MERGE64_FIRST(offset), vki_u32, MERGE64_SECOND(offset),
1343 vki_u32, MERGE64_FIRST(len), vki_u32, MERGE64_SECOND(len), int, advice);
1346 /* ---------------------------------------------------------------------
1348 ------------------------------------------------------------------ */
1350 // Nb: this wrapper has to pad/unpad memory around the syscall itself,
1351 // and this allows us to control exactly the code that gets run while
1352 // the padding is in place.
1356 PRINT("sys_io_setup ( %lu, %#lx )", ARG1,ARG2);
1357 PRE_REG_READ2(long, "io_setup",
1358 unsigned, nr_events, vki_aio_context_t *, ctxp);
1359 PRE_MEM_WRITE( "io_setup(ctxp)", ARG2, sizeof(vki_aio_context_t) );
1365 struct vki_aio_ring *r;
1367 size = VG_PGROUNDUP(sizeof(struct vki_aio_ring) +
1368 ARG1*sizeof(struct vki_io_event));
1369 r = *(struct vki_aio_ring **)ARG2;
1370 vg_assert(ML_(valid_client_addr)((Addr)r, size, tid, "io_setup"));
1372 ML_(notify_core_and_tool_of_mmap)( (Addr)r, size,
1373 VKI_PROT_READ | VKI_PROT_WRITE,
1374 VKI_MAP_ANONYMOUS, -1, 0 );
1376 POST_MEM_WRITE( ARG2, sizeof(vki_aio_context_t) );
1379 // Nb: This wrapper is "Special" because we need 'size' to do the unmap
1380 // after the syscall. We must get 'size' from the aio_ring structure,
1381 // before the syscall, while the aio_ring structure still exists. (And we
1382 // know that we must look at the aio_ring structure because Tom inspected the
1383 // kernel and glibc sources to see what they do, yuk.)
1385 // XXX This segment can be implicitly unmapped when aio
1386 // file-descriptors are closed...
1391 PRINT("sys_io_destroy ( %llu )", (ULong)ARG1);
1392 PRE_REG_READ1(long, "io_destroy", vki_aio_context_t, ctx);
1394 // If we are going to seg fault (due to a bogus ARG1) do it as late as
1396 if (ML_(safe_to_deref)( (void*)ARG1, sizeof(struct vki_aio_ring))) {
1397 struct vki_aio_ring *r = (struct vki_aio_ring *)ARG1;
1398 size = VG_PGROUNDUP(sizeof(struct vki_aio_ring) +
1399 r->nr*sizeof(struct vki_io_event));
1402 SET_STATUS_from_SysRes( VG_(do_syscall1)(SYSNO, ARG1) );
1404 if (SUCCESS && RES == 0) {
1405 Bool d = VG_(am_notify_munmap)( ARG1, size );
1406 VG_TRACK( die_mem_munmap, ARG1, size );
1408 VG_(discard_translations)( (Addr64)ARG1, (ULong)size,
1409 "PRE(sys_io_destroy)" );
1413 PRE(sys_io_getevents)
1415 *flags |= SfMayBlock;
1416 PRINT("sys_io_getevents ( %llu, %lld, %lld, %#lx, %#lx )",
1417 (ULong)ARG1,(Long)ARG2,(Long)ARG3,ARG4,ARG5);
1418 PRE_REG_READ5(long, "io_getevents",
1419 vki_aio_context_t, ctx_id, long, min_nr, long, nr,
1420 struct io_event *, events,
1421 struct timespec *, timeout);
1423 PRE_MEM_WRITE( "io_getevents(events)",
1424 ARG4, sizeof(struct vki_io_event)*ARG3 );
1426 PRE_MEM_READ( "io_getevents(timeout)",
1427 ARG5, sizeof(struct vki_timespec));
1429 POST(sys_io_getevents)
1434 POST_MEM_WRITE( ARG4, sizeof(struct vki_io_event)*RES );
1435 for (i = 0; i < RES; i++) {
1436 const struct vki_io_event *vev = ((struct vki_io_event *)ARG4) + i;
1437 const struct vki_iocb *cb = (struct vki_iocb *)(Addr)vev->obj;
1439 switch (cb->aio_lio_opcode) {
1440 case VKI_IOCB_CMD_PREAD:
1441 if (vev->result > 0)
1442 POST_MEM_WRITE( cb->aio_buf, vev->result );
1445 case VKI_IOCB_CMD_PWRITE:
1448 case VKI_IOCB_CMD_FSYNC:
1451 case VKI_IOCB_CMD_FDSYNC:
1454 case VKI_IOCB_CMD_PREADV:
1455 if (vev->result > 0) {
1456 struct vki_iovec * vec = (struct vki_iovec *)(Addr)cb->aio_buf;
1457 Int remains = vev->result;
1460 for (j = 0; j < cb->aio_nbytes; j++) {
1461 Int nReadThisBuf = vec[j].iov_len;
1462 if (nReadThisBuf > remains) nReadThisBuf = remains;
1463 POST_MEM_WRITE( (Addr)vec[j].iov_base, nReadThisBuf );
1464 remains -= nReadThisBuf;
1465 if (remains < 0) VG_(core_panic)("io_getevents(PREADV): remains < 0");
1470 case VKI_IOCB_CMD_PWRITEV:
1474 VG_(message)(Vg_DebugMsg,
1475 "Warning: unhandled io_getevents opcode: %u\n",
1476 cb->aio_lio_opcode);
1487 PRINT("sys_io_submit ( %llu, %ld, %#lx )", (ULong)ARG1,ARG2,ARG3);
1488 PRE_REG_READ3(long, "io_submit",
1489 vki_aio_context_t, ctx_id, long, nr,
1490 struct iocb **, iocbpp);
1491 PRE_MEM_READ( "io_submit(iocbpp)", ARG3, ARG2*sizeof(struct vki_iocb *) );
1493 for (i = 0; i < ARG2; i++) {
1494 struct vki_iocb *cb = ((struct vki_iocb **)ARG3)[i];
1495 struct vki_iovec *iov;
1497 PRE_MEM_READ( "io_submit(iocb)", (Addr)cb, sizeof(struct vki_iocb) );
1498 switch (cb->aio_lio_opcode) {
1499 case VKI_IOCB_CMD_PREAD:
1500 PRE_MEM_WRITE( "io_submit(PREAD)", cb->aio_buf, cb->aio_nbytes );
1503 case VKI_IOCB_CMD_PWRITE:
1504 PRE_MEM_READ( "io_submit(PWRITE)", cb->aio_buf, cb->aio_nbytes );
1507 case VKI_IOCB_CMD_FSYNC:
1510 case VKI_IOCB_CMD_FDSYNC:
1513 case VKI_IOCB_CMD_PREADV:
1514 iov = (struct vki_iovec *)(Addr)cb->aio_buf;
1515 PRE_MEM_READ( "io_submit(PREADV)", cb->aio_buf, cb->aio_nbytes * sizeof(struct vki_iovec) );
1516 for (j = 0; j < cb->aio_nbytes; j++)
1517 PRE_MEM_WRITE( "io_submit(PREADV(iov[i]))", (Addr)iov[j].iov_base, iov[j].iov_len );
1520 case VKI_IOCB_CMD_PWRITEV:
1521 iov = (struct vki_iovec *)(Addr)cb->aio_buf;
1522 PRE_MEM_READ( "io_submit(PWRITEV)", cb->aio_buf, cb->aio_nbytes * sizeof(struct vki_iovec) );
1523 for (j = 0; j < cb->aio_nbytes; j++)
1524 PRE_MEM_READ( "io_submit(PWRITEV(iov[i]))", (Addr)iov[j].iov_base, iov[j].iov_len );
1528 VG_(message)(Vg_DebugMsg,"Warning: unhandled io_submit opcode: %u\n",
1529 cb->aio_lio_opcode);
1538 PRINT("sys_io_cancel ( %llu, %#lx, %#lx )", (ULong)ARG1,ARG2,ARG3);
1539 PRE_REG_READ3(long, "io_cancel",
1540 vki_aio_context_t, ctx_id, struct iocb *, iocb,
1541 struct io_event *, result);
1542 PRE_MEM_READ( "io_cancel(iocb)", ARG2, sizeof(struct vki_iocb) );
1543 PRE_MEM_WRITE( "io_cancel(result)", ARG3, sizeof(struct vki_io_event) );
1547 POST_MEM_WRITE( ARG3, sizeof(struct vki_io_event) );
1550 /* ---------------------------------------------------------------------
1551 *_mempolicy wrappers
1552 ------------------------------------------------------------------ */
1556 PRINT("sys_mbind ( %#lx, %lu, %ld, %#lx, %lu, %lu )", ARG1,ARG2,ARG3,ARG4,ARG5,ARG6);
1557 PRE_REG_READ6(long, "mbind",
1558 unsigned long, start, unsigned long, len,
1559 unsigned long, policy, unsigned long *, nodemask,
1560 unsigned long, maxnode, unsigned, flags);
1562 PRE_MEM_READ( "mbind(nodemask)", ARG4,
1563 VG_ROUNDUP( ARG5, sizeof(UWord) ) / sizeof(UWord) );
1566 PRE(sys_set_mempolicy)
1568 PRINT("sys_set_mempolicy ( %ld, %#lx, %ld )", ARG1,ARG2,ARG3);
1569 PRE_REG_READ3(long, "set_mempolicy",
1570 int, policy, unsigned long *, nodemask,
1571 unsigned long, maxnode);
1572 PRE_MEM_READ( "set_mempolicy(nodemask)", ARG2,
1573 VG_ROUNDUP( ARG3, sizeof(UWord) ) / sizeof(UWord) );
1576 PRE(sys_get_mempolicy)
1578 PRINT("sys_get_mempolicy ( %#lx, %#lx, %ld, %#lx, %lx )", ARG1,ARG2,ARG3,ARG4,ARG5);
1579 PRE_REG_READ5(long, "get_mempolicy",
1580 int *, policy, unsigned long *, nodemask,
1581 unsigned long, maxnode, unsigned long, addr,
1582 unsigned long, flags);
1584 PRE_MEM_WRITE( "get_mempolicy(policy)", ARG1, sizeof(Int) );
1586 PRE_MEM_WRITE( "get_mempolicy(nodemask)", ARG2,
1587 VG_ROUNDUP( ARG3, sizeof(UWord) * 8 ) / sizeof(UWord) );
1589 POST(sys_get_mempolicy)
1592 POST_MEM_WRITE( ARG1, sizeof(Int) );
1594 POST_MEM_WRITE( ARG2, VG_ROUNDUP( ARG3, sizeof(UWord) * 8 ) / sizeof(UWord) );
1597 /* ---------------------------------------------------------------------
1599 ------------------------------------------------------------------ */
1601 PRE(sys_inotify_init)
1603 PRINT("sys_inotify_init ( )");
1604 PRE_REG_READ0(long, "inotify_init");
1606 POST(sys_inotify_init)
1609 if (!ML_(fd_allowed)(RES, "inotify_init", tid, True)) {
1611 SET_STATUS_Failure( VKI_EMFILE );
1613 if (VG_(clo_track_fds))
1614 ML_(record_fd_open_nameless) (tid, RES);
1618 PRE(sys_inotify_init1)
1620 PRINT("sys_inotify_init ( %ld )", ARG1);
1621 PRE_REG_READ1(long, "inotify_init", int, flag);
1624 POST(sys_inotify_init1)
1627 if (!ML_(fd_allowed)(RES, "inotify_init", tid, True)) {
1629 SET_STATUS_Failure( VKI_EMFILE );
1631 if (VG_(clo_track_fds))
1632 ML_(record_fd_open_nameless) (tid, RES);
1636 PRE(sys_inotify_add_watch)
1638 PRINT( "sys_inotify_add_watch ( %ld, %#lx, %lx )", ARG1,ARG2,ARG3);
1639 PRE_REG_READ3(long, "inotify_add_watch", int, fd, char *, path, int, mask);
1640 PRE_MEM_RASCIIZ( "inotify_add_watch(path)", ARG2 );
1643 PRE(sys_inotify_rm_watch)
1645 PRINT( "sys_inotify_rm_watch ( %ld, %lx )", ARG1,ARG2);
1646 PRE_REG_READ2(long, "inotify_rm_watch", int, fd, int, wd);
1649 /* ---------------------------------------------------------------------
1651 ------------------------------------------------------------------ */
1655 PRINT("sys_mq_open( %#lx(%s), %ld, %lld, %#lx )",
1656 ARG1,(char*)ARG1,ARG2,(ULong)ARG3,ARG4);
1657 PRE_REG_READ4(long, "mq_open",
1658 const char *, name, int, oflag, vki_mode_t, mode,
1659 struct mq_attr *, attr);
1660 PRE_MEM_RASCIIZ( "mq_open(name)", ARG1 );
1661 if ((ARG2 & VKI_O_CREAT) != 0 && ARG4 != 0) {
1662 const struct vki_mq_attr *attr = (struct vki_mq_attr *)ARG4;
1663 PRE_MEM_READ( "mq_open(attr->mq_maxmsg)",
1664 (Addr)&attr->mq_maxmsg, sizeof(attr->mq_maxmsg) );
1665 PRE_MEM_READ( "mq_open(attr->mq_msgsize)",
1666 (Addr)&attr->mq_msgsize, sizeof(attr->mq_msgsize) );
1672 if (!ML_(fd_allowed)(RES, "mq_open", tid, True)) {
1674 SET_STATUS_Failure( VKI_EMFILE );
1676 if (VG_(clo_track_fds))
1677 ML_(record_fd_open_with_given_name)(tid, RES, (Char*)ARG1);
1683 PRINT("sys_mq_unlink ( %#lx(%s) )", ARG1,(char*)ARG1);
1684 PRE_REG_READ1(long, "mq_unlink", const char *, name);
1685 PRE_MEM_RASCIIZ( "mq_unlink(name)", ARG1 );
1688 PRE(sys_mq_timedsend)
1690 *flags |= SfMayBlock;
1691 PRINT("sys_mq_timedsend ( %ld, %#lx, %llu, %ld, %#lx )",
1692 ARG1,ARG2,(ULong)ARG3,ARG4,ARG5);
1693 PRE_REG_READ5(long, "mq_timedsend",
1694 vki_mqd_t, mqdes, const char *, msg_ptr, vki_size_t, msg_len,
1695 unsigned int, msg_prio, const struct timespec *, abs_timeout);
1696 if (!ML_(fd_allowed)(ARG1, "mq_timedsend", tid, False)) {
1697 SET_STATUS_Failure( VKI_EBADF );
1699 PRE_MEM_READ( "mq_timedsend(msg_ptr)", ARG2, ARG3 );
1701 PRE_MEM_READ( "mq_timedsend(abs_timeout)", ARG5,
1702 sizeof(struct vki_timespec) );
1706 PRE(sys_mq_timedreceive)
1708 *flags |= SfMayBlock;
1709 PRINT("sys_mq_timedreceive( %ld, %#lx, %llu, %#lx, %#lx )",
1710 ARG1,ARG2,(ULong)ARG3,ARG4,ARG5);
1711 PRE_REG_READ5(ssize_t, "mq_timedreceive",
1712 vki_mqd_t, mqdes, char *, msg_ptr, vki_size_t, msg_len,
1713 unsigned int *, msg_prio,
1714 const struct timespec *, abs_timeout);
1715 if (!ML_(fd_allowed)(ARG1, "mq_timedreceive", tid, False)) {
1716 SET_STATUS_Failure( VKI_EBADF );
1718 PRE_MEM_WRITE( "mq_timedreceive(msg_ptr)", ARG2, ARG3 );
1720 PRE_MEM_WRITE( "mq_timedreceive(msg_prio)",
1721 ARG4, sizeof(unsigned int) );
1723 PRE_MEM_READ( "mq_timedreceive(abs_timeout)",
1724 ARG5, sizeof(struct vki_timespec) );
1727 POST(sys_mq_timedreceive)
1729 POST_MEM_WRITE( ARG2, ARG3 );
1731 POST_MEM_WRITE( ARG4, sizeof(unsigned int) );
1736 PRINT("sys_mq_notify( %ld, %#lx )", ARG1,ARG2 );
1737 PRE_REG_READ2(long, "mq_notify",
1738 vki_mqd_t, mqdes, const struct sigevent *, notification);
1739 if (!ML_(fd_allowed)(ARG1, "mq_notify", tid, False))
1740 SET_STATUS_Failure( VKI_EBADF );
1742 PRE_MEM_READ( "mq_notify(notification)",
1743 ARG2, sizeof(struct vki_sigevent) );
1746 PRE(sys_mq_getsetattr)
1748 PRINT("sys_mq_getsetattr( %ld, %#lx, %#lx )", ARG1,ARG2,ARG3 );
1749 PRE_REG_READ3(long, "mq_getsetattr",
1750 vki_mqd_t, mqdes, const struct mq_attr *, mqstat,
1751 struct mq_attr *, omqstat);
1752 if (!ML_(fd_allowed)(ARG1, "mq_getsetattr", tid, False)) {
1753 SET_STATUS_Failure( VKI_EBADF );
1756 const struct vki_mq_attr *attr = (struct vki_mq_attr *)ARG2;
1757 PRE_MEM_READ( "mq_getsetattr(mqstat->mq_flags)",
1758 (Addr)&attr->mq_flags, sizeof(attr->mq_flags) );
1761 PRE_MEM_WRITE( "mq_getsetattr(omqstat)", ARG3,
1762 sizeof(struct vki_mq_attr) );
1765 POST(sys_mq_getsetattr)
1768 POST_MEM_WRITE( ARG3, sizeof(struct vki_mq_attr) );
1771 /* ---------------------------------------------------------------------
1773 ------------------------------------------------------------------ */
1775 PRE(sys_clock_settime)
1777 PRINT("sys_clock_settime( %ld, %#lx )", ARG1,ARG2);
1778 PRE_REG_READ2(long, "clock_settime",
1779 vki_clockid_t, clk_id, const struct timespec *, tp);
1780 PRE_MEM_READ( "clock_settime(tp)", ARG2, sizeof(struct vki_timespec) );
1783 PRE(sys_clock_gettime)
1785 PRINT("sys_clock_gettime( %ld, %#lx )" , ARG1,ARG2);
1786 PRE_REG_READ2(long, "clock_gettime",
1787 vki_clockid_t, clk_id, struct timespec *, tp);
1788 PRE_MEM_WRITE( "clock_gettime(tp)", ARG2, sizeof(struct vki_timespec) );
1790 POST(sys_clock_gettime)
1792 POST_MEM_WRITE( ARG2, sizeof(struct vki_timespec) );
1795 PRE(sys_clock_getres)
1797 PRINT("sys_clock_getres( %ld, %#lx )" , ARG1,ARG2);
1798 // Nb: we can't use "RES" as the param name because that's a macro
1800 PRE_REG_READ2(long, "clock_getres",
1801 vki_clockid_t, clk_id, struct timespec *, res);
1803 PRE_MEM_WRITE( "clock_getres(res)", ARG2, sizeof(struct vki_timespec) );
1805 POST(sys_clock_getres)
1808 POST_MEM_WRITE( ARG2, sizeof(struct vki_timespec) );
1811 PRE(sys_clock_nanosleep)
1813 *flags |= SfMayBlock|SfPostOnFail;
1814 PRINT("sys_clock_nanosleep( %ld, %ld, %#lx, %#lx )", ARG1,ARG2,ARG3,ARG4);
1815 PRE_REG_READ4(int32_t, "clock_nanosleep",
1816 vki_clockid_t, clkid, int, flags,
1817 const struct timespec *, rqtp, struct timespec *, rmtp);
1818 PRE_MEM_READ( "clock_nanosleep(rqtp)", ARG3, sizeof(struct vki_timespec) );
1820 PRE_MEM_WRITE( "clock_nanosleep(rmtp)", ARG4, sizeof(struct vki_timespec) );
1822 POST(sys_clock_nanosleep)
1824 if (ARG4 != 0 && FAILURE && ERR == VKI_EINTR)
1825 POST_MEM_WRITE( ARG4, sizeof(struct vki_timespec) );
1828 /* ---------------------------------------------------------------------
1830 ------------------------------------------------------------------ */
1832 PRE(sys_timer_create)
1834 PRINT("sys_timer_create( %ld, %#lx, %#lx )", ARG1,ARG2,ARG3);
1835 PRE_REG_READ3(long, "timer_create",
1836 vki_clockid_t, clockid, struct sigevent *, evp,
1837 vki_timer_t *, timerid);
1839 PRE_MEM_READ( "timer_create(evp)", ARG2, sizeof(struct vki_sigevent) );
1840 PRE_MEM_WRITE( "timer_create(timerid)", ARG3, sizeof(vki_timer_t) );
1842 POST(sys_timer_create)
1844 POST_MEM_WRITE( ARG3, sizeof(vki_timer_t) );
1847 PRE(sys_timer_settime)
1849 PRINT("sys_timer_settime( %lld, %ld, %#lx, %#lx )", (ULong)ARG1,ARG2,ARG3,ARG4);
1850 PRE_REG_READ4(long, "timer_settime",
1851 vki_timer_t, timerid, int, flags,
1852 const struct itimerspec *, value,
1853 struct itimerspec *, ovalue);
1854 PRE_MEM_READ( "timer_settime(value)", ARG3,
1855 sizeof(struct vki_itimerspec) );
1857 PRE_MEM_WRITE( "timer_settime(ovalue)", ARG4,
1858 sizeof(struct vki_itimerspec) );
1860 POST(sys_timer_settime)
1863 POST_MEM_WRITE( ARG4, sizeof(struct vki_itimerspec) );
1866 PRE(sys_timer_gettime)
1868 PRINT("sys_timer_gettime( %lld, %#lx )", (ULong)ARG1,ARG2);
1869 PRE_REG_READ2(long, "timer_gettime",
1870 vki_timer_t, timerid, struct itimerspec *, value);
1871 PRE_MEM_WRITE( "timer_gettime(value)", ARG2,
1872 sizeof(struct vki_itimerspec));
1874 POST(sys_timer_gettime)
1876 POST_MEM_WRITE( ARG2, sizeof(struct vki_itimerspec) );
1879 PRE(sys_timer_getoverrun)
1881 PRINT("sys_timer_getoverrun( %#lx )", ARG1);
1882 PRE_REG_READ1(long, "timer_getoverrun", vki_timer_t, timerid);
1885 PRE(sys_timer_delete)
1887 PRINT("sys_timer_delete( %#lx )", ARG1);
1888 PRE_REG_READ1(long, "timer_delete", vki_timer_t, timerid);
1891 /* ---------------------------------------------------------------------
1893 See also http://lwn.net/Articles/260172/ for an overview.
1894 See also /usr/src/linux/fs/timerfd.c for the implementation.
1895 ------------------------------------------------------------------ */
1897 /* Returns True if running on 2.6.22, else False (or False if
1898 cannot be determined). */
1899 static Bool linux_kernel_2_6_22(void)
1901 static Int result = -1;
1907 res = VG_(open)("/proc/sys/kernel/osrelease", 0, 0);
1908 if (sr_isError(res))
1911 read = VG_(read)(fd, release, sizeof(release) - 1);
1912 vg_assert(read >= 0);
1915 //VG_(printf)("kernel release = %s\n", release);
1916 result = (VG_(strncmp)(release, "2.6.22", 6) == 0
1917 && (release[6] < '0' || release[6] > '9'));
1919 vg_assert(result == 0 || result == 1);
1923 PRE(sys_timerfd_create)
1925 if (linux_kernel_2_6_22()) {
1926 /* 2.6.22 kernel: timerfd system call. */
1927 PRINT("sys_timerfd ( %ld, %ld, %#lx )", ARG1, ARG2, ARG3);
1928 PRE_REG_READ3(long, "sys_timerfd",
1929 int, fd, int, clockid, const struct itimerspec *, tmr);
1930 PRE_MEM_READ("timerfd(tmr)", ARG3,
1931 sizeof(struct vki_itimerspec) );
1932 if ((Word)ARG1 != -1L && !ML_(fd_allowed)(ARG1, "timerfd", tid, False))
1933 SET_STATUS_Failure( VKI_EBADF );
1935 /* 2.6.24 and later kernels: timerfd_create system call. */
1936 PRINT("sys_timerfd_create (%ld, %ld )", ARG1, ARG2);
1937 PRE_REG_READ2(long, "timerfd_create", int, clockid, int, flags);
1940 POST(sys_timerfd_create)
1942 if (linux_kernel_2_6_22())
1944 /* 2.6.22 kernel: timerfd system call. */
1945 if (!ML_(fd_allowed)(RES, "timerfd", tid, True)) {
1947 SET_STATUS_Failure( VKI_EMFILE );
1949 if (VG_(clo_track_fds))
1950 ML_(record_fd_open_nameless) (tid, RES);
1955 /* 2.6.24 and later kernels: timerfd_create system call. */
1956 if (!ML_(fd_allowed)(RES, "timerfd_create", tid, True)) {
1958 SET_STATUS_Failure( VKI_EMFILE );
1960 if (VG_(clo_track_fds))
1961 ML_(record_fd_open_nameless) (tid, RES);
1966 PRE(sys_timerfd_gettime)
1968 PRINT("sys_timerfd_gettime ( %ld, %#lx )", ARG1, ARG2);
1969 PRE_REG_READ2(long, "timerfd_gettime",
1971 struct vki_itimerspec*, otmr);
1972 if (!ML_(fd_allowed)(ARG1, "timerfd_gettime", tid, False))
1973 SET_STATUS_Failure(VKI_EBADF);
1975 PRE_MEM_WRITE("timerfd_gettime(result)",
1976 ARG2, sizeof(struct vki_itimerspec));
1978 POST(sys_timerfd_gettime)
1981 POST_MEM_WRITE(ARG2, sizeof(struct vki_itimerspec));
1984 PRE(sys_timerfd_settime)
1986 PRINT("sys_timerfd_settime ( %ld, %ld, %#lx, %#lx )", ARG1, ARG2, ARG3, ARG4);
1987 PRE_REG_READ4(long, "timerfd_settime",
1990 const struct vki_itimerspec*, utmr,
1991 struct vki_itimerspec*, otmr);
1992 if (!ML_(fd_allowed)(ARG1, "timerfd_settime", tid, False))
1993 SET_STATUS_Failure(VKI_EBADF);
1996 PRE_MEM_READ("timerfd_settime(result)",
1997 ARG3, sizeof(struct vki_itimerspec));
2000 PRE_MEM_WRITE("timerfd_settime(result)",
2001 ARG4, sizeof(struct vki_itimerspec));
2005 POST(sys_timerfd_settime)
2007 if (RES == 0 && ARG4 != 0)
2008 POST_MEM_WRITE(ARG4, sizeof(struct vki_itimerspec));
2011 /* ---------------------------------------------------------------------
2012 capabilities wrappers
2013 ------------------------------------------------------------------ */
2017 PRINT("sys_capget ( %#lx, %#lx )", ARG1, ARG2 );
2018 PRE_REG_READ2(long, "capget",
2019 vki_cap_user_header_t, header, vki_cap_user_data_t, data);
2020 PRE_MEM_READ( "capget(header)", ARG1,
2021 sizeof(struct __vki_user_cap_header_struct) );
2022 PRE_MEM_WRITE( "capget(data)", ARG2,
2023 sizeof(struct __vki_user_cap_data_struct) );
2027 if (ARG2 != (Addr)NULL)
2028 POST_MEM_WRITE( ARG2, sizeof(struct __vki_user_cap_data_struct) );
2033 PRINT("sys_capset ( %#lx, %#lx )", ARG1, ARG2 );
2034 PRE_REG_READ2(long, "capset",
2035 vki_cap_user_header_t, header,
2036 const vki_cap_user_data_t, data);
2037 PRE_MEM_READ( "capset(header)",
2038 ARG1, sizeof(struct __vki_user_cap_header_struct) );
2039 PRE_MEM_READ( "capset(data)",
2040 ARG2, sizeof(struct __vki_user_cap_data_struct) );
2043 /* ---------------------------------------------------------------------
2044 16-bit uid/gid/groups wrappers
2045 ------------------------------------------------------------------ */
2049 PRINT("sys_getuid16 ( )");
2050 PRE_REG_READ0(long, "getuid16");
2055 PRINT("sys_setuid16 ( %ld )", ARG1);
2056 PRE_REG_READ1(long, "setuid16", vki_old_uid_t, uid);
2061 PRINT("sys_getgid16 ( )");
2062 PRE_REG_READ0(long, "getgid16");
2067 PRINT("sys_setgid16 ( %ld )", ARG1);
2068 PRE_REG_READ1(long, "setgid16", vki_old_gid_t, gid);
2073 PRINT("sys_geteuid16 ( )");
2074 PRE_REG_READ0(long, "geteuid16");
2079 PRINT("sys_getegid16 ( )");
2080 PRE_REG_READ0(long, "getegid16");
2085 PRINT("setreuid16 ( 0x%lx, 0x%lx )", ARG1, ARG2);
2086 PRE_REG_READ2(long, "setreuid16", vki_old_uid_t, ruid, vki_old_uid_t, euid);
2091 PRINT("sys_setregid16 ( %ld, %ld )", ARG1, ARG2);
2092 PRE_REG_READ2(long, "setregid16", vki_old_gid_t, rgid, vki_old_gid_t, egid);
2095 PRE(sys_getgroups16)
2097 PRINT("sys_getgroups16 ( %ld, %#lx )", ARG1, ARG2);
2098 PRE_REG_READ2(long, "getgroups16", int, size, vki_old_gid_t *, list);
2100 PRE_MEM_WRITE( "getgroups16(list)", ARG2, ARG1 * sizeof(vki_old_gid_t) );
2102 POST(sys_getgroups16)
2105 if (ARG1 > 0 && RES > 0)
2106 POST_MEM_WRITE( ARG2, RES * sizeof(vki_old_gid_t) );
2109 PRE(sys_setgroups16)
2111 PRINT("sys_setgroups16 ( %llu, %#lx )", (ULong)ARG1, ARG2);
2112 PRE_REG_READ2(long, "setgroups16", int, size, vki_old_gid_t *, list);
2114 PRE_MEM_READ( "setgroups16(list)", ARG2, ARG1 * sizeof(vki_old_gid_t) );
2117 /* ---------------------------------------------------------------------
2119 ------------------------------------------------------------------ */
2123 PRINT("sys_chown16 ( %#lx, 0x%lx, 0x%lx )", ARG1,ARG2,ARG3);
2124 PRE_REG_READ3(long, "chown16",
2126 vki_old_uid_t, owner, vki_old_gid_t, group);
2127 PRE_MEM_RASCIIZ( "chown16(path)", ARG1 );
2132 PRINT("sys_fchown16 ( %ld, %ld, %ld )", ARG1,ARG2,ARG3);
2133 PRE_REG_READ3(long, "fchown16",
2134 unsigned int, fd, vki_old_uid_t, owner, vki_old_gid_t, group);
2137 /* ---------------------------------------------------------------------
2139 ------------------------------------------------------------------ */
2143 *flags |= SfMayBlock;
2144 PRINT("sys_setxattr ( %#lx, %#lx, %#lx, %llu, %ld )",
2145 ARG1, ARG2, ARG3, (ULong)ARG4, ARG5);
2146 PRE_REG_READ5(long, "setxattr",
2147 char *, path, char *, name,
2148 void *, value, vki_size_t, size, int, flags);
2149 PRE_MEM_RASCIIZ( "setxattr(path)", ARG1 );
2150 PRE_MEM_RASCIIZ( "setxattr(name)", ARG2 );
2151 PRE_MEM_READ( "setxattr(value)", ARG3, ARG4 );
2156 *flags |= SfMayBlock;
2157 PRINT("sys_lsetxattr ( %#lx, %#lx, %#lx, %llu, %ld )",
2158 ARG1, ARG2, ARG3, (ULong)ARG4, ARG5);
2159 PRE_REG_READ5(long, "lsetxattr",
2160 char *, path, char *, name,
2161 void *, value, vki_size_t, size, int, flags);
2162 PRE_MEM_RASCIIZ( "lsetxattr(path)", ARG1 );
2163 PRE_MEM_RASCIIZ( "lsetxattr(name)", ARG2 );
2164 PRE_MEM_READ( "lsetxattr(value)", ARG3, ARG4 );
2169 *flags |= SfMayBlock;
2170 PRINT("sys_fsetxattr ( %ld, %#lx, %#lx, %llu, %ld )",
2171 ARG1, ARG2, ARG3, (ULong)ARG4, ARG5);
2172 PRE_REG_READ5(long, "fsetxattr",
2173 int, fd, char *, name, void *, value,
2174 vki_size_t, size, int, flags);
2175 PRE_MEM_RASCIIZ( "fsetxattr(name)", ARG2 );
2176 PRE_MEM_READ( "fsetxattr(value)", ARG3, ARG4 );
2181 *flags |= SfMayBlock;
2182 PRINT("sys_getxattr ( %#lx, %#lx, %#lx, %llu )", ARG1,ARG2,ARG3, (ULong)ARG4);
2183 PRE_REG_READ4(ssize_t, "getxattr",
2184 char *, path, char *, name, void *, value, vki_size_t, size);
2185 PRE_MEM_RASCIIZ( "getxattr(path)", ARG1 );
2186 PRE_MEM_RASCIIZ( "getxattr(name)", ARG2 );
2187 PRE_MEM_WRITE( "getxattr(value)", ARG3, ARG4 );
2192 if (RES > 0 && ARG3 != (Addr)NULL) {
2193 POST_MEM_WRITE( ARG3, RES );
2199 *flags |= SfMayBlock;
2200 PRINT("sys_lgetxattr ( %#lx, %#lx, %#lx, %llu )", ARG1,ARG2,ARG3, (ULong)ARG4);
2201 PRE_REG_READ4(ssize_t, "lgetxattr",
2202 char *, path, char *, name, void *, value, vki_size_t, size);
2203 PRE_MEM_RASCIIZ( "lgetxattr(path)", ARG1 );
2204 PRE_MEM_RASCIIZ( "lgetxattr(name)", ARG2 );
2205 PRE_MEM_WRITE( "lgetxattr(value)", ARG3, ARG4 );
2210 if (RES > 0 && ARG3 != (Addr)NULL) {
2211 POST_MEM_WRITE( ARG3, RES );
2217 *flags |= SfMayBlock;
2218 PRINT("sys_fgetxattr ( %ld, %#lx, %#lx, %llu )", ARG1, ARG2, ARG3, (ULong)ARG4);
2219 PRE_REG_READ4(ssize_t, "fgetxattr",
2220 int, fd, char *, name, void *, value, vki_size_t, size);
2221 PRE_MEM_RASCIIZ( "fgetxattr(name)", ARG2 );
2222 PRE_MEM_WRITE( "fgetxattr(value)", ARG3, ARG4 );
2226 if (RES > 0 && ARG3 != (Addr)NULL)
2227 POST_MEM_WRITE( ARG3, RES );
2232 *flags |= SfMayBlock;
2233 PRINT("sys_listxattr ( %#lx, %#lx, %llu )", ARG1, ARG2, (ULong)ARG3);
2234 PRE_REG_READ3(ssize_t, "listxattr",
2235 char *, path, char *, list, vki_size_t, size);
2236 PRE_MEM_RASCIIZ( "listxattr(path)", ARG1 );
2237 PRE_MEM_WRITE( "listxattr(list)", ARG2, ARG3 );
2241 if (RES > 0 && ARG2 != (Addr)NULL)
2242 POST_MEM_WRITE( ARG2, RES );
2247 *flags |= SfMayBlock;
2248 PRINT("sys_llistxattr ( %#lx, %#lx, %llu )", ARG1, ARG2, (ULong)ARG3);
2249 PRE_REG_READ3(ssize_t, "llistxattr",
2250 char *, path, char *, list, vki_size_t, size);
2251 PRE_MEM_RASCIIZ( "llistxattr(path)", ARG1 );
2252 PRE_MEM_WRITE( "llistxattr(list)", ARG2, ARG3 );
2254 POST(sys_llistxattr)
2256 if (RES > 0 && ARG2 != (Addr)NULL)
2257 POST_MEM_WRITE( ARG2, RES );
2262 *flags |= SfMayBlock;
2263 PRINT("sys_flistxattr ( %ld, %#lx, %llu )", ARG1, ARG2, (ULong)ARG3);
2264 PRE_REG_READ3(ssize_t, "flistxattr",
2265 int, fd, char *, list, vki_size_t, size);
2266 PRE_MEM_WRITE( "flistxattr(list)", ARG2, ARG3 );
2268 POST(sys_flistxattr)
2270 if (RES > 0 && ARG2 != (Addr)NULL)
2271 POST_MEM_WRITE( ARG2, RES );
2274 PRE(sys_removexattr)
2276 *flags |= SfMayBlock;
2277 PRINT("sys_removexattr ( %#lx, %#lx )", ARG1, ARG2);
2278 PRE_REG_READ2(long, "removexattr", char *, path, char *, name);
2279 PRE_MEM_RASCIIZ( "removexattr(path)", ARG1 );
2280 PRE_MEM_RASCIIZ( "removexattr(name)", ARG2 );
2283 PRE(sys_lremovexattr)
2285 *flags |= SfMayBlock;
2286 PRINT("sys_lremovexattr ( %#lx, %#lx )", ARG1, ARG2);
2287 PRE_REG_READ2(long, "lremovexattr", char *, path, char *, name);
2288 PRE_MEM_RASCIIZ( "lremovexattr(path)", ARG1 );
2289 PRE_MEM_RASCIIZ( "lremovexattr(name)", ARG2 );
2292 PRE(sys_fremovexattr)
2294 *flags |= SfMayBlock;
2295 PRINT("sys_fremovexattr ( %ld, %#lx )", ARG1, ARG2);
2296 PRE_REG_READ2(long, "fremovexattr", int, fd, char *, name);
2297 PRE_MEM_RASCIIZ( "fremovexattr(name)", ARG2 );
2300 /* ---------------------------------------------------------------------
2302 ------------------------------------------------------------------ */
2304 PRE(sys_sched_setparam)
2306 PRINT("sched_setparam ( %ld, %#lx )", ARG1, ARG2 );
2307 PRE_REG_READ2(long, "sched_setparam",
2308 vki_pid_t, pid, struct sched_param *, p);
2309 PRE_MEM_READ( "sched_setparam(p)", ARG2, sizeof(struct vki_sched_param) );
2311 POST(sys_sched_setparam)
2313 POST_MEM_WRITE( ARG2, sizeof(struct vki_sched_param) );
2316 PRE(sys_sched_getparam)
2318 PRINT("sched_getparam ( %ld, %#lx )", ARG1, ARG2 );
2319 PRE_REG_READ2(long, "sched_getparam",
2320 vki_pid_t, pid, struct sched_param *, p);
2321 PRE_MEM_WRITE( "sched_getparam(p)", ARG2, sizeof(struct vki_sched_param) );
2323 POST(sys_sched_getparam)
2325 POST_MEM_WRITE( ARG2, sizeof(struct vki_sched_param) );
2328 PRE(sys_sched_getscheduler)
2330 PRINT("sys_sched_getscheduler ( %ld )", ARG1);
2331 PRE_REG_READ1(long, "sched_getscheduler", vki_pid_t, pid);
2334 PRE(sys_sched_setscheduler)
2336 PRINT("sys_sched_setscheduler ( %ld, %ld, %#lx )", ARG1,ARG2,ARG3);
2337 PRE_REG_READ3(long, "sched_setscheduler",
2338 vki_pid_t, pid, int, policy, struct sched_param *, p);
2340 PRE_MEM_READ( "sched_setscheduler(p)",
2341 ARG3, sizeof(struct vki_sched_param));
2344 PRE(sys_sched_yield)
2346 *flags |= SfMayBlock;
2347 PRINT("sched_yield()");
2348 PRE_REG_READ0(long, "sys_sched_yield");
2351 PRE(sys_sched_get_priority_max)
2353 PRINT("sched_get_priority_max ( %ld )", ARG1);
2354 PRE_REG_READ1(long, "sched_get_priority_max", int, policy);
2357 PRE(sys_sched_get_priority_min)
2359 PRINT("sched_get_priority_min ( %ld )", ARG1);
2360 PRE_REG_READ1(long, "sched_get_priority_min", int, policy);
2363 PRE(sys_sched_rr_get_interval)
2365 PRINT("sys_sched_rr_get_interval ( %ld, %#lx )", ARG1, ARG2);
2366 PRE_REG_READ2(int, "sched_rr_get_interval",
2368 struct vki_timespec *, tp);
2369 PRE_MEM_WRITE("sched_rr_get_interval(timespec)",
2370 ARG2, sizeof(struct vki_timespec));
2373 POST(sys_sched_rr_get_interval)
2375 POST_MEM_WRITE(ARG2, sizeof(struct vki_timespec));
2378 PRE(sys_sched_setaffinity)
2380 PRINT("sched_setaffinity ( %ld, %ld, %#lx )", ARG1, ARG2, ARG3);
2381 PRE_REG_READ3(long, "sched_setaffinity",
2382 vki_pid_t, pid, unsigned int, len, unsigned long *, mask);
2383 PRE_MEM_READ( "sched_setaffinity(mask)", ARG3, ARG2);
2386 PRE(sys_sched_getaffinity)
2388 PRINT("sched_getaffinity ( %ld, %ld, %#lx )", ARG1, ARG2, ARG3);
2389 PRE_REG_READ3(long, "sched_getaffinity",
2390 vki_pid_t, pid, unsigned int, len, unsigned long *, mask);
2391 PRE_MEM_WRITE( "sched_getaffinity(mask)", ARG3, ARG2);
2393 POST(sys_sched_getaffinity)
2395 POST_MEM_WRITE(ARG3, ARG2);
2398 /* ---------------------------------------------------------------------
2399 miscellaneous wrappers
2400 ------------------------------------------------------------------ */
2404 *flags |= SfMayBlock;
2405 PRINT("sys_munlockall ( )");
2406 PRE_REG_READ0(long, "munlockall");
2409 // This has different signatures for different platforms.
2411 // x86: int sys_pipe(unsigned long __user *fildes);
2412 // AMD64: long sys_pipe(int *fildes);
2413 // ppc32: int sys_pipe(int __user *fildes);
2414 // ppc64: int sys_pipe(int __user *fildes);
2416 // The type of the argument is most important, and it is an array of 32 bit
2417 // values in all cases. (The return type differs across platforms, but it
2418 // is not used.) So we use 'int' as its type. This fixed bug #113230 which
2419 // was caused by using an array of 'unsigned long's, which didn't work on
2423 PRINT("sys_pipe ( %#lx )", ARG1);
2424 PRE_REG_READ1(int, "pipe", int *, filedes);
2425 PRE_MEM_WRITE( "pipe(filedes)", ARG1, 2*sizeof(int) );
2429 Int *p = (Int *)ARG1;
2430 if (!ML_(fd_allowed)(p[0], "pipe", tid, True) ||
2431 !ML_(fd_allowed)(p[1], "pipe", tid, True)) {
2434 SET_STATUS_Failure( VKI_EMFILE );
2436 POST_MEM_WRITE( ARG1, 2*sizeof(int) );
2437 if (VG_(clo_track_fds)) {
2438 ML_(record_fd_open_nameless)(tid, p[0]);
2439 ML_(record_fd_open_nameless)(tid, p[1]);
2444 /* pipe2 (a kernel 2.6.twentysomething invention) is like pipe, except
2445 there's a second arg containing flags to be applied to the new file
2446 descriptors. It hardly seems worth the effort to factor out the
2447 duplicated code, hence: */
2450 PRINT("sys_pipe2 ( %#lx, %#lx )", ARG1, ARG2);
2451 PRE_REG_READ2(int, "pipe", int *, filedes, long, flags);
2452 PRE_MEM_WRITE( "pipe2(filedes)", ARG1, 2*sizeof(int) );
2456 Int *p = (Int *)ARG1;
2457 if (!ML_(fd_allowed)(p[0], "pipe2", tid, True) ||
2458 !ML_(fd_allowed)(p[1], "pipe2", tid, True)) {
2461 SET_STATUS_Failure( VKI_EMFILE );
2463 POST_MEM_WRITE( ARG1, 2*sizeof(int) );
2464 if (VG_(clo_track_fds)) {
2465 ML_(record_fd_open_nameless)(tid, p[0]);
2466 ML_(record_fd_open_nameless)(tid, p[1]);
2473 PRINT("sys_dup3 ( %ld, %ld, %ld )", ARG1,ARG2,ARG3);
2474 PRE_REG_READ3(long, "dup3", unsigned int, oldfd, unsigned int, newfd, int, flags);
2475 if (!ML_(fd_allowed)(ARG2, "dup3", tid, True))
2476 SET_STATUS_Failure( VKI_EBADF );
2482 if (VG_(clo_track_fds))
2483 ML_(record_fd_open_named)(tid, RES);
2488 PRINT("sys_quotactl (0x%lx, %#lx, 0x%lx, 0x%lx )", ARG1,ARG2,ARG3, ARG4);
2489 PRE_REG_READ4(long, "quotactl",
2490 unsigned int, cmd, const char *, special, vki_qid_t, id,
2492 PRE_MEM_RASCIIZ( "quotactl(special)", ARG2 );
2497 *flags |= SfMayBlock;
2498 PRINT("sys_waitid( %ld, %ld, %#lx, %ld, %#lx )", ARG1,ARG2,ARG3,ARG4,ARG5);
2499 PRE_REG_READ5(int32_t, "sys_waitid",
2500 int, which, vki_pid_t, pid, struct vki_siginfo *, infop,
2501 int, options, struct vki_rusage *, ru);
2502 PRE_MEM_WRITE( "waitid(infop)", ARG3, sizeof(struct vki_siginfo) );
2504 PRE_MEM_WRITE( "waitid(ru)", ARG5, sizeof(struct vki_rusage) );
2508 POST_MEM_WRITE( ARG3, sizeof(struct vki_siginfo) );
2510 POST_MEM_WRITE( ARG5, sizeof(struct vki_rusage) );
2513 PRE(sys_sync_file_range)
2515 *flags |= SfMayBlock;
2516 #if VG_WORDSIZE == 4
2517 PRINT("sys_sync_file_range ( %ld, %lld, %lld, %ld )",
2518 ARG1,MERGE64(ARG2,ARG3),MERGE64(ARG4,ARG5),ARG6);
2519 PRE_REG_READ6(long, "sync_file_range",
2521 unsigned, MERGE64_FIRST(offset), unsigned, MERGE64_SECOND(offset),
2522 unsigned, MERGE64_FIRST(nbytes), unsigned, MERGE64_SECOND(nbytes),
2523 unsigned int, flags);
2524 #elif VG_WORDSIZE == 8
2525 PRINT("sys_sync_file_range ( %ld, %lld, %lld, %ld )",
2526 ARG1,(Long)ARG2,(Long)ARG3,ARG4);
2527 PRE_REG_READ4(long, "sync_file_range",
2528 int, fd, vki_loff_t, offset, vki_loff_t, nbytes,
2529 unsigned int, flags);
2531 # error Unexpected word size
2533 if (!ML_(fd_allowed)(ARG1, "sync_file_range", tid, False))
2534 SET_STATUS_Failure( VKI_EBADF );
2537 PRE(sys_sync_file_range2)
2539 *flags |= SfMayBlock;
2540 #if VG_WORDSIZE == 4
2541 PRINT("sys_sync_file_range2 ( %ld, %ld, %lld, %lld )",
2542 ARG1,ARG2,MERGE64(ARG3,ARG4),MERGE64(ARG5,ARG6));
2543 PRE_REG_READ6(long, "sync_file_range2",
2544 int, fd, unsigned int, flags,
2545 unsigned, MERGE64_FIRST(offset), unsigned, MERGE64_SECOND(offset),
2546 unsigned, MERGE64_FIRST(nbytes), unsigned, MERGE64_SECOND(nbytes));
2547 #elif VG_WORDSIZE == 8
2548 PRINT("sys_sync_file_range2 ( %ld, %ld, %lld, %lld )",
2549 ARG1,ARG2,(Long)ARG3,(Long)ARG4);
2550 PRE_REG_READ4(long, "sync_file_range2",
2551 int, fd, unsigned int, flags,
2552 vki_loff_t, offset, vki_loff_t, nbytes);
2554 # error Unexpected word size
2556 if (!ML_(fd_allowed)(ARG1, "sync_file_range2", tid, False))
2557 SET_STATUS_Failure( VKI_EBADF );
2562 PRINT("sys_stime ( %#lx )", ARG1);
2563 PRE_REG_READ1(int, "stime", vki_time_t*, t);
2564 PRE_MEM_READ( "stime(t)", ARG1, sizeof(vki_time_t) );
2567 PRE(sys_perf_counter_open)
2569 PRINT("sys_perf_counter_open ( %#lx, %ld, %ld, %ld, %ld )",
2570 ARG1,ARG2,ARG3,ARG4,ARG5);
2571 PRE_REG_READ5(long, "perf_counter_open",
2572 struct vki_perf_counter_attr *, attr,
2573 vki_pid_t, pid, int, cpu, int, group_fd,
2574 unsigned long, flags);
2575 PRE_MEM_READ( "perf_counter_open(attr)",
2576 ARG1, sizeof(struct vki_perf_counter_attr) );
2579 POST(sys_perf_counter_open)
2582 if (!ML_(fd_allowed)(RES, "perf_counter_open", tid, True)) {
2584 SET_STATUS_Failure( VKI_EMFILE );
2586 if (VG_(clo_track_fds))
2587 ML_(record_fd_open_nameless)(tid, RES);
2593 PRINT("sys_getcpu ( %#lx, %#lx, %#lx )" , ARG1,ARG2,ARG3);
2594 PRE_REG_READ3(int, "getcpu",
2595 unsigned *, cpu, unsigned *, node, struct vki_getcpu_cache *, tcache);
2597 PRE_MEM_WRITE( "getcpu(cpu)", ARG1, sizeof(unsigned) );
2599 PRE_MEM_WRITE( "getcpu(node)", ARG2, sizeof(unsigned) );
2601 PRE_MEM_WRITE( "getcpu(tcache)", ARG3, sizeof(struct vki_getcpu_cache) );
2607 POST_MEM_WRITE( ARG1, sizeof(unsigned) );
2609 POST_MEM_WRITE( ARG2, sizeof(unsigned) );
2611 POST_MEM_WRITE( ARG3, sizeof(struct vki_getcpu_cache) );
2614 /* ---------------------------------------------------------------------
2616 ------------------------------------------------------------------ */
2620 *flags |= SfMayBlock;
2621 PRINT("sys_utime ( %#lx, %#lx )", ARG1,ARG2);
2622 PRE_REG_READ2(long, "utime", char *, filename, struct utimbuf *, buf);
2623 PRE_MEM_RASCIIZ( "utime(filename)", ARG1 );
2625 PRE_MEM_READ( "utime(buf)", ARG2, sizeof(struct vki_utimbuf) );
2628 /* ---------------------------------------------------------------------
2630 ------------------------------------------------------------------ */
2634 PRINT("sys_lseek ( %ld, %ld, %ld )", ARG1,ARG2,ARG3);
2635 PRE_REG_READ3(vki_off_t, "lseek",
2636 unsigned int, fd, vki_off_t, offset, unsigned int, whence);
2639 /* ---------------------------------------------------------------------
2641 ------------------------------------------------------------------ */
2645 PRINT( "sys_sigpending ( %#lx )", ARG1 );
2646 PRE_REG_READ1(long, "sigpending", vki_old_sigset_t *, set);
2647 PRE_MEM_WRITE( "sigpending(set)", ARG1, sizeof(vki_old_sigset_t));
2649 POST(sys_sigpending)
2651 POST_MEM_WRITE( ARG1, sizeof(vki_old_sigset_t) ) ;
2654 // This syscall is not used on amd64/Linux -- it only provides
2655 // sys_rt_sigprocmask, which uses sigset_t rather than old_sigset_t.
2656 // This wrapper is only suitable for 32-bit architectures.
2657 // (XXX: so how is it that PRE(sys_sigpending) above doesn't need
2658 // conditional compilation like this?)
2659 #if defined(VGP_x86_linux) || defined(VGP_ppc32_linux)
2660 PRE(sys_sigprocmask)
2662 vki_old_sigset_t* set;
2663 vki_old_sigset_t* oldset;
2664 vki_sigset_t bigger_set;
2665 vki_sigset_t bigger_oldset;
2667 PRINT("sys_sigprocmask ( %ld, %#lx, %#lx )",ARG1,ARG2,ARG3);
2668 PRE_REG_READ3(long, "sigprocmask",
2669 int, how, vki_old_sigset_t *, set, vki_old_sigset_t *, oldset);
2671 PRE_MEM_READ( "sigprocmask(set)", ARG2, sizeof(vki_old_sigset_t));
2673 PRE_MEM_WRITE( "sigprocmask(oldset)", ARG3, sizeof(vki_old_sigset_t));
2675 // Nb: We must convert the smaller vki_old_sigset_t params into bigger
2676 // vki_sigset_t params.
2677 set = (vki_old_sigset_t*)ARG2;
2678 oldset = (vki_old_sigset_t*)ARG3;
2680 VG_(memset)(&bigger_set, 0, sizeof(vki_sigset_t));
2681 VG_(memset)(&bigger_oldset, 0, sizeof(vki_sigset_t));
2683 bigger_set.sig[0] = *(vki_old_sigset_t*)set;
2685 SET_STATUS_from_SysRes(
2686 VG_(do_sys_sigprocmask) ( tid, ARG1 /*how*/,
2687 set ? &bigger_set : NULL,
2688 oldset ? &bigger_oldset : NULL)
2692 *oldset = bigger_oldset.sig[0];
2695 *flags |= SfPollAfter;
2697 POST(sys_sigprocmask)
2700 if (RES == 0 && ARG3 != 0)
2701 POST_MEM_WRITE( ARG3, sizeof(vki_old_sigset_t));
2707 PRINT("sys_signalfd ( %d, %#lx, %llu )", (Int)ARG1,ARG2,(ULong)ARG3);
2708 PRE_REG_READ3(long, "sys_signalfd",
2709 int, fd, vki_sigset_t *, sigmask, vki_size_t, sigsetsize);
2710 PRE_MEM_READ( "signalfd(sigmask)", ARG2, sizeof(vki_sigset_t) );
2711 if ((int)ARG1 != -1 && !ML_(fd_allowed)(ARG1, "signalfd", tid, False))
2712 SET_STATUS_Failure( VKI_EBADF );
2716 if (!ML_(fd_allowed)(RES, "signalfd", tid, True)) {
2718 SET_STATUS_Failure( VKI_EMFILE );
2720 if (VG_(clo_track_fds))
2721 ML_(record_fd_open_nameless) (tid, RES);
2727 PRINT("sys_signalfd4 ( %d, %#lx, %llu, %ld )", (Int)ARG1,ARG2,(ULong)ARG3,ARG4);
2728 PRE_REG_READ4(long, "sys_signalfd4",
2729 int, fd, vki_sigset_t *, sigmask, vki_size_t, sigsetsize, int, flags);
2730 PRE_MEM_READ( "signalfd(sigmask)", ARG2, sizeof(vki_sigset_t) );
2731 if ((int)ARG1 != -1 && !ML_(fd_allowed)(ARG1, "signalfd", tid, False))
2732 SET_STATUS_Failure( VKI_EBADF );
2736 if (!ML_(fd_allowed)(RES, "signalfd4", tid, True)) {
2738 SET_STATUS_Failure( VKI_EMFILE );
2740 if (VG_(clo_track_fds))
2741 ML_(record_fd_open_nameless) (tid, RES);
2746 /* ---------------------------------------------------------------------
2748 ------------------------------------------------------------------ */
2750 PRE(sys_rt_sigaction)
2752 PRINT("sys_rt_sigaction ( %ld, %#lx, %#lx, %ld )", ARG1,ARG2,ARG3,ARG4);
2753 PRE_REG_READ4(long, "rt_sigaction",
2754 int, signum, const struct sigaction *, act,
2755 struct sigaction *, oldact, vki_size_t, sigsetsize);
2758 vki_sigaction_toK_t *sa = (vki_sigaction_toK_t *)ARG2;
2759 PRE_MEM_READ( "rt_sigaction(act->sa_handler)", (Addr)&sa->ksa_handler, sizeof(sa->ksa_handler));
2760 PRE_MEM_READ( "rt_sigaction(act->sa_mask)", (Addr)&sa->sa_mask, sizeof(sa->sa_mask));
2761 PRE_MEM_READ( "rt_sigaction(act->sa_flags)", (Addr)&sa->sa_flags, sizeof(sa->sa_flags));
2762 if (sa->sa_flags & VKI_SA_RESTORER)
2763 PRE_MEM_READ( "rt_sigaction(act->sa_restorer)", (Addr)&sa->sa_restorer, sizeof(sa->sa_restorer));
2766 PRE_MEM_WRITE( "rt_sigaction(oldact)", ARG3, sizeof(vki_sigaction_fromK_t));
2768 // XXX: doesn't seem right to be calling do_sys_sigaction for
2769 // sys_rt_sigaction... perhaps this function should be renamed
2770 // VG_(do_sys_rt_sigaction)() --njn
2772 SET_STATUS_from_SysRes(
2773 VG_(do_sys_sigaction)(ARG1, (const vki_sigaction_toK_t *)ARG2,
2774 (vki_sigaction_fromK_t *)ARG3)
2777 POST(sys_rt_sigaction)
2780 if (RES == 0 && ARG3 != 0)
2781 POST_MEM_WRITE( ARG3, sizeof(vki_sigaction_fromK_t));
2784 PRE(sys_rt_sigprocmask)
2786 PRINT("sys_rt_sigprocmask ( %ld, %#lx, %#lx, %llu )",ARG1,ARG2,ARG3,(ULong)ARG4);
2787 PRE_REG_READ4(long, "rt_sigprocmask",
2788 int, how, vki_sigset_t *, set, vki_sigset_t *, oldset,
2789 vki_size_t, sigsetsize);
2791 PRE_MEM_READ( "rt_sigprocmask(set)", ARG2, sizeof(vki_sigset_t));
2793 PRE_MEM_WRITE( "rt_sigprocmask(oldset)", ARG3, sizeof(vki_sigset_t));
2795 // Like the kernel, we fail if the sigsetsize is not exactly what we expect.
2796 if (sizeof(vki_sigset_t) != ARG4)
2797 SET_STATUS_Failure( VKI_EMFILE );
2799 SET_STATUS_from_SysRes(
2800 VG_(do_sys_sigprocmask) ( tid, ARG1 /*how*/,
2801 (vki_sigset_t*) ARG2,
2802 (vki_sigset_t*) ARG3 )
2807 *flags |= SfPollAfter;
2809 POST(sys_rt_sigprocmask)
2812 if (RES == 0 && ARG3 != 0)
2813 POST_MEM_WRITE( ARG3, sizeof(vki_sigset_t));
2816 PRE(sys_rt_sigpending)
2818 PRINT( "sys_rt_sigpending ( %#lx )", ARG1 );
2819 PRE_REG_READ2(long, "rt_sigpending",
2820 vki_sigset_t *, set, vki_size_t, sigsetsize);
2821 PRE_MEM_WRITE( "rt_sigpending(set)", ARG1, sizeof(vki_sigset_t));
2823 POST(sys_rt_sigpending)
2825 POST_MEM_WRITE( ARG1, sizeof(vki_sigset_t) ) ;
2828 PRE(sys_rt_sigtimedwait)
2830 *flags |= SfMayBlock;
2831 PRINT("sys_rt_sigtimedwait ( %#lx, %#lx, %#lx, %lld )",
2832 ARG1,ARG2,ARG3,(ULong)ARG4);
2833 PRE_REG_READ4(long, "rt_sigtimedwait",
2834 const vki_sigset_t *, set, vki_siginfo_t *, info,
2835 const struct timespec *, timeout, vki_size_t, sigsetsize);
2837 PRE_MEM_READ( "rt_sigtimedwait(set)", ARG1, sizeof(vki_sigset_t));
2839 PRE_MEM_WRITE( "rt_sigtimedwait(info)", ARG2, sizeof(vki_siginfo_t) );
2841 PRE_MEM_READ( "rt_sigtimedwait(timeout)",
2842 ARG3, sizeof(struct vki_timespec) );
2844 POST(sys_rt_sigtimedwait)
2847 POST_MEM_WRITE( ARG2, sizeof(vki_siginfo_t) );
2850 PRE(sys_rt_sigqueueinfo)
2852 PRINT("sys_rt_sigqueueinfo(%ld, %ld, %#lx)", ARG1, ARG2, ARG3);
2853 PRE_REG_READ3(long, "rt_sigqueueinfo",
2854 int, pid, int, sig, vki_siginfo_t *, uinfo);
2856 PRE_MEM_READ( "rt_sigqueueinfo(uinfo)", ARG3, VKI_SI_MAX_SIZE );
2858 POST(sys_rt_sigqueueinfo)
2860 if (!ML_(client_signal_OK)(ARG2))
2861 SET_STATUS_Failure( VKI_EINVAL );
2864 PRE(sys_rt_tgsigqueueinfo)
2866 PRINT("sys_rt_tgsigqueueinfo(%ld, %ld, %ld, %#lx)", ARG1, ARG2, ARG3, ARG4);
2867 PRE_REG_READ4(long, "rt_tgsigqueueinfo",
2868 int, tgid, int, pid, int, sig, vki_siginfo_t *, uinfo);
2870 PRE_MEM_READ( "rt_tgsigqueueinfo(uinfo)", ARG4, VKI_SI_MAX_SIZE );
2873 POST(sys_rt_tgsigqueueinfo)
2875 if (!ML_(client_signal_OK)(ARG3))
2876 SET_STATUS_Failure( VKI_EINVAL );
2879 // XXX: x86-specific? The kernel prototypes for the different archs are
2880 // hard to decipher.
2881 PRE(sys_rt_sigsuspend)
2883 /* The C library interface to sigsuspend just takes a pointer to
2884 a signal mask but this system call has two arguments - a pointer
2885 to the mask and the number of bytes used by it. The kernel insists
2886 on the size being equal to sizeof(sigset_t) however and will just
2887 return EINVAL if it isn't.
2889 *flags |= SfMayBlock;
2890 PRINT("sys_rt_sigsuspend ( %#lx, %ld )", ARG1,ARG2 );
2891 PRE_REG_READ2(int, "rt_sigsuspend", vki_sigset_t *, mask, vki_size_t, size)
2892 if (ARG1 != (Addr)NULL) {
2893 PRE_MEM_READ( "rt_sigsuspend(mask)", ARG1, sizeof(vki_sigset_t) );
2897 /* ---------------------------------------------------------------------
2898 linux msg* wrapper helpers
2899 ------------------------------------------------------------------ */
2902 ML_(linux_PRE_sys_msgsnd) ( ThreadId tid,
2903 UWord arg0, UWord arg1, UWord arg2, UWord arg3 )
2905 /* int msgsnd(int msqid, struct msgbuf *msgp, size_t msgsz, int msgflg); */
2906 struct vki_msgbuf *msgp = (struct vki_msgbuf *)arg1;
2907 PRE_MEM_READ( "msgsnd(msgp->mtype)", (Addr)&msgp->mtype, sizeof(msgp->mtype) );
2908 PRE_MEM_READ( "msgsnd(msgp->mtext)", (Addr)&msgp->mtext, arg2 );
2912 ML_(linux_PRE_sys_msgrcv) ( ThreadId tid,
2913 UWord arg0, UWord arg1, UWord arg2,
2914 UWord arg3, UWord arg4 )
2916 /* ssize_t msgrcv(int msqid, struct msgbuf *msgp, size_t msgsz,
2917 long msgtyp, int msgflg); */
2918 struct vki_msgbuf *msgp = (struct vki_msgbuf *)arg1;
2919 PRE_MEM_WRITE( "msgrcv(msgp->mtype)", (Addr)&msgp->mtype, sizeof(msgp->mtype) );
2920 PRE_MEM_WRITE( "msgrcv(msgp->mtext)", (Addr)&msgp->mtext, arg2 );
2923 ML_(linux_POST_sys_msgrcv) ( ThreadId tid,
2925 UWord arg0, UWord arg1, UWord arg2,
2926 UWord arg3, UWord arg4 )
2928 struct vki_msgbuf *msgp = (struct vki_msgbuf *)arg1;
2929 POST_MEM_WRITE( (Addr)&msgp->mtype, sizeof(msgp->mtype) );
2930 POST_MEM_WRITE( (Addr)&msgp->mtext, res );
2934 ML_(linux_PRE_sys_msgctl) ( ThreadId tid,
2935 UWord arg0, UWord arg1, UWord arg2 )
2937 /* int msgctl(int msqid, int cmd, struct msqid_ds *buf); */
2938 switch (arg1 /* cmd */) {
2941 case VKI_IPC_INFO|VKI_IPC_64:
2942 case VKI_MSG_INFO|VKI_IPC_64:
2943 PRE_MEM_WRITE( "msgctl(IPC_INFO, buf)",
2944 arg2, sizeof(struct vki_msginfo) );
2948 PRE_MEM_WRITE( "msgctl(IPC_STAT, buf)",
2949 arg2, sizeof(struct vki_msqid_ds) );
2951 case VKI_IPC_STAT|VKI_IPC_64:
2952 case VKI_MSG_STAT|VKI_IPC_64:
2953 PRE_MEM_WRITE( "msgctl(IPC_STAT, arg.buf)",
2954 arg2, sizeof(struct vki_msqid64_ds) );
2957 PRE_MEM_READ( "msgctl(IPC_SET, arg.buf)",
2958 arg2, sizeof(struct vki_msqid_ds) );
2960 case VKI_IPC_SET|VKI_IPC_64:
2961 PRE_MEM_READ( "msgctl(IPC_SET, arg.buf)",
2962 arg2, sizeof(struct vki_msqid64_ds) );
2967 ML_(linux_POST_sys_msgctl) ( ThreadId tid,
2969 UWord arg0, UWord arg1, UWord arg2 )
2971 switch (arg1 /* cmd */) {
2974 case VKI_IPC_INFO|VKI_IPC_64:
2975 case VKI_MSG_INFO|VKI_IPC_64:
2976 POST_MEM_WRITE( arg2, sizeof(struct vki_msginfo) );
2980 POST_MEM_WRITE( arg2, sizeof(struct vki_msqid_ds) );
2982 case VKI_IPC_STAT|VKI_IPC_64:
2983 case VKI_MSG_STAT|VKI_IPC_64:
2984 POST_MEM_WRITE( arg2, sizeof(struct vki_msqid64_ds) );
2989 /* ---------------------------------------------------------------------
2991 ------------------------------------------------------------------ */
2998 if (ARG3 & VKI_O_CREAT) {
3000 PRINT("sys_openat ( %ld, %#lx(%s), %ld, %ld )",ARG1,ARG2,(char*)ARG2,ARG3,ARG4);
3001 PRE_REG_READ4(long, "openat",
3002 int, dfd, const char *, filename, int, flags, int, mode);
3005 PRINT("sys_openat ( %ld, %#lx(%s), %ld )",ARG1,ARG2,(char*)ARG2,ARG3);
3006 PRE_REG_READ3(long, "openat",
3007 int, dfd, const char *, filename, int, flags);
3010 if (ARG1 != VKI_AT_FDCWD && !ML_(fd_allowed)(ARG1, "openat", tid, False))
3011 SET_STATUS_Failure( VKI_EBADF );
3013 PRE_MEM_RASCIIZ( "openat(filename)", ARG2 );
3015 /* Handle the case where the open is of /proc/self/cmdline or
3016 /proc/<pid>/cmdline, and just give it a copy of the fd for the
3017 fake file we cooked up at startup (in m_main). Also, seek the
3018 cloned fd back to the start. */
3020 VG_(sprintf)(name, "/proc/%d/cmdline", VG_(getpid)());
3021 if (ML_(safe_to_deref)( (void*)ARG2, 1 )
3022 && (VG_(strcmp)((Char *)ARG2, name) == 0
3023 || VG_(strcmp)((Char *)ARG2, "/proc/self/cmdline") == 0)) {
3024 sres = VG_(dup)( VG_(cl_cmdline_fd) );
3025 SET_STATUS_from_SysRes( sres );
3026 if (!sr_isError(sres)) {
3027 OffT off = VG_(lseek)( sr_Res(sres), 0, VKI_SEEK_SET );
3029 SET_STATUS_Failure( VKI_EMFILE );
3034 /* Otherwise handle normally */
3035 *flags |= SfMayBlock;
3041 if (!ML_(fd_allowed)(RES, "openat", tid, True)) {
3043 SET_STATUS_Failure( VKI_EMFILE );
3045 if (VG_(clo_track_fds))
3046 ML_(record_fd_open_with_given_name)(tid, RES, (Char*)ARG2);
3052 *flags |= SfMayBlock;
3053 PRINT("sys_mkdirat ( %ld, %#lx(%s), %ld )", ARG1,ARG2,(char*)ARG2,ARG3);
3054 PRE_REG_READ3(long, "mkdirat",
3055 int, dfd, const char *, pathname, int, mode);
3056 PRE_MEM_RASCIIZ( "mkdirat(pathname)", ARG2 );
3061 PRINT("sys_mknodat ( %ld, %#lx(%s), 0x%lx, 0x%lx )", ARG1,ARG2,(char*)ARG2,ARG3,ARG4 );
3062 PRE_REG_READ4(long, "mknodat",
3063 int, dfd, const char *, pathname, int, mode, unsigned, dev);
3064 PRE_MEM_RASCIIZ( "mknodat(pathname)", ARG2 );
3069 PRINT("sys_fchownat ( %ld, %#lx(%s), 0x%lx, 0x%lx )", ARG1,ARG2,(char*)ARG2,ARG3,ARG4);
3070 PRE_REG_READ4(long, "fchownat",
3071 int, dfd, const char *, path,
3072 vki_uid_t, owner, vki_gid_t, group);
3073 PRE_MEM_RASCIIZ( "fchownat(path)", ARG2 );
3078 PRINT("sys_futimesat ( %ld, %#lx(%s), %#lx )", ARG1,ARG2,(char*)ARG2,ARG3);
3079 PRE_REG_READ3(long, "futimesat",
3080 int, dfd, char *, filename, struct timeval *, tvp);
3082 PRE_MEM_RASCIIZ( "futimesat(filename)", ARG2 );
3084 PRE_MEM_READ( "futimesat(tvp)", ARG3, 2 * sizeof(struct vki_timeval) );
3089 PRINT("sys_utimensat ( %ld, %#lx(%s), %#lx, 0x%lx )", ARG1,ARG2,(char*)ARG2,ARG3,ARG4);
3090 PRE_REG_READ4(long, "utimensat",
3091 int, dfd, char *, filename, struct timespec *, utimes, int, flags);
3093 PRE_MEM_RASCIIZ( "utimensat(filename)", ARG2 );
3095 PRE_MEM_READ( "utimensat(tvp)", ARG3, 2 * sizeof(struct vki_timespec) );
3100 PRINT("sys_newfstatat ( %ld, %#lx(%s), %#lx )", ARG1,ARG2,(char*)ARG2,ARG3);
3101 PRE_REG_READ3(long, "fstatat",
3102 int, dfd, char *, file_name, struct stat *, buf);
3103 PRE_MEM_RASCIIZ( "fstatat(file_name)", ARG2 );
3104 PRE_MEM_WRITE( "fstatat(buf)", ARG3, sizeof(struct vki_stat) );
3107 POST(sys_newfstatat)
3109 POST_MEM_WRITE( ARG3, sizeof(struct vki_stat) );
3114 *flags |= SfMayBlock;
3115 PRINT("sys_unlinkat ( %ld, %#lx(%s) )", ARG1,ARG2,(char*)ARG2);
3116 PRE_REG_READ2(long, "unlinkat", int, dfd, const char *, pathname);
3117 PRE_MEM_RASCIIZ( "unlinkat(pathname)", ARG2 );
3122 PRINT("sys_renameat ( %ld, %#lx(%s), %ld, %#lx(%s) )", ARG1,ARG2,(char*)ARG2,ARG3,ARG4,(char*)ARG4);
3123 PRE_REG_READ4(long, "renameat",
3124 int, olddfd, const char *, oldpath,
3125 int, newdfd, const char *, newpath);
3126 PRE_MEM_RASCIIZ( "renameat(oldpath)", ARG2 );
3127 PRE_MEM_RASCIIZ( "renameat(newpath)", ARG4 );
3132 *flags |= SfMayBlock;
3133 PRINT("sys_linkat ( %ld, %#lx(%s), %ld, %#lx(%s), %ld )",ARG1,ARG2,(char*)ARG2,ARG3,ARG4,(char*)ARG4,ARG5);
3134 PRE_REG_READ5(long, "linkat",
3135 int, olddfd, const char *, oldpath,
3136 int, newdfd, const char *, newpath,
3138 PRE_MEM_RASCIIZ( "linkat(oldpath)", ARG2);
3139 PRE_MEM_RASCIIZ( "linkat(newpath)", ARG4);
3144 *flags |= SfMayBlock;
3145 PRINT("sys_symlinkat ( %#lx(%s), %ld, %#lx(%s) )",ARG1,(char*)ARG1,ARG2,ARG3,(char*)ARG3);
3146 PRE_REG_READ3(long, "symlinkat",
3147 const char *, oldpath, int, newdfd, const char *, newpath);
3148 PRE_MEM_RASCIIZ( "symlinkat(oldpath)", ARG1 );
3149 PRE_MEM_RASCIIZ( "symlinkat(newpath)", ARG3 );
3157 PRINT("sys_readlinkat ( %ld, %#lx(%s), %#lx, %llu )", ARG1,ARG2,(char*)ARG2,ARG3,(ULong)ARG4);
3158 PRE_REG_READ4(long, "readlinkat",
3159 int, dfd, const char *, path, char *, buf, int, bufsiz);
3160 PRE_MEM_RASCIIZ( "readlinkat(path)", ARG2 );
3161 PRE_MEM_WRITE( "readlinkat(buf)", ARG3,ARG4 );
3164 * Handle the case where readlinkat is looking at /proc/self/exe or
3167 VG_(sprintf)(name, "/proc/%d/exe", VG_(getpid)());
3168 if (ML_(safe_to_deref)((void*)ARG2, 1)
3169 && (VG_(strcmp)((Char *)ARG2, name) == 0
3170 || VG_(strcmp)((Char *)ARG2, "/proc/self/exe") == 0)) {
3171 VG_(sprintf)(name, "/proc/self/fd/%d", VG_(cl_exec_fd));
3172 SET_STATUS_from_SysRes( VG_(do_syscall4)(saved, ARG1, (UWord)name,
3176 SET_STATUS_from_SysRes( VG_(do_syscall4)(saved, ARG1, ARG2, ARG3, ARG4));
3179 if (SUCCESS && RES > 0)
3180 POST_MEM_WRITE( ARG3, RES );
3185 PRINT("sys_fchmodat ( %ld, %#lx(%s), %ld )", ARG1,ARG2,(char*)ARG2,ARG3);
3186 PRE_REG_READ3(long, "fchmodat",
3187 int, dfd, const char *, path, vki_mode_t, mode);
3188 PRE_MEM_RASCIIZ( "fchmodat(path)", ARG2 );
3193 PRINT("sys_faccessat ( %ld, %#lx(%s), %ld )", ARG1,ARG2,(char*)ARG2,ARG3);
3194 PRE_REG_READ3(long, "faccessat",
3195 int, dfd, const char *, pathname, int, mode);
3196 PRE_MEM_RASCIIZ( "faccessat(pathname)", ARG2 );
3199 /* ---------------------------------------------------------------------
3200 p{read,write}v wrappers
3201 ------------------------------------------------------------------ */
3206 struct vki_iovec * vec;
3207 *flags |= SfMayBlock;
3208 #if VG_WORDSIZE == 4
3209 /* Note that the offset argument here is in lo+hi order on both
3210 big and little endian platforms... */
3211 PRINT("sys_preadv ( %ld, %#lx, %llu, %lld )",ARG1,ARG2,(ULong)ARG3,LOHI64(ARG4,ARG5));
3212 PRE_REG_READ5(ssize_t, "preadv",
3213 unsigned long, fd, const struct iovec *, vector,
3214 unsigned long, count, vki_u32, offset_low,
3215 vki_u32, offset_high);
3216 #elif VG_WORDSIZE == 8
3217 PRINT("sys_preadv ( %ld, %#lx, %llu, %lld )",ARG1,ARG2,(ULong)ARG3,(Long)ARG4);
3218 PRE_REG_READ4(ssize_t, "preadv",
3219 unsigned long, fd, const struct iovec *, vector,
3220 unsigned long, count, Word, offset);
3222 # error Unexpected word size
3224 if (!ML_(fd_allowed)(ARG1, "preadv", tid, False)) {
3225 SET_STATUS_Failure( VKI_EBADF );
3227 PRE_MEM_READ( "preadv(vector)", ARG2, ARG3 * sizeof(struct vki_iovec) );
3230 /* ToDo: don't do any of the following if the vector is invalid */
3231 vec = (struct vki_iovec *)ARG2;
3232 for (i = 0; i < (Int)ARG3; i++)
3233 PRE_MEM_WRITE( "preadv(vector[...])",
3234 (Addr)vec[i].iov_base, vec[i].iov_len );
3244 struct vki_iovec * vec = (struct vki_iovec *)ARG2;
3247 /* RES holds the number of bytes read. */
3248 for (i = 0; i < (Int)ARG3; i++) {
3249 Int nReadThisBuf = vec[i].iov_len;
3250 if (nReadThisBuf > remains) nReadThisBuf = remains;
3251 POST_MEM_WRITE( (Addr)vec[i].iov_base, nReadThisBuf );
3252 remains -= nReadThisBuf;
3253 if (remains < 0) VG_(core_panic)("preadv: remains < 0");
3261 struct vki_iovec * vec;
3262 *flags |= SfMayBlock;
3263 #if VG_WORDSIZE == 4
3264 /* Note that the offset argument here is in lo+hi order on both
3265 big and little endian platforms... */
3266 PRINT("sys_pwritev ( %ld, %#lx, %llu, %lld )",ARG1,ARG2,(ULong)ARG3,LOHI64(ARG4,ARG5));
3267 PRE_REG_READ5(ssize_t, "pwritev",
3268 unsigned long, fd, const struct iovec *, vector,
3269 unsigned long, count, vki_u32, offset_low,
3270 vki_u32, offset_high);
3271 #elif VG_WORDSIZE == 8
3272 PRINT("sys_pwritev ( %ld, %#lx, %llu, %lld )",ARG1,ARG2,(ULong)ARG3,(Long)ARG4);
3273 PRE_REG_READ4(ssize_t, "pwritev",
3274 unsigned long, fd, const struct iovec *, vector,
3275 unsigned long, count, Word, offset);
3277 # error Unexpected word size
3279 if (!ML_(fd_allowed)(ARG1, "pwritev", tid, False)) {
3280 SET_STATUS_Failure( VKI_EBADF );
3282 PRE_MEM_READ( "pwritev(vector)",
3283 ARG2, ARG3 * sizeof(struct vki_iovec) );
3285 /* ToDo: don't do any of the following if the vector is invalid */
3286 vec = (struct vki_iovec *)ARG2;
3287 for (i = 0; i < (Int)ARG3; i++)
3288 PRE_MEM_READ( "pwritev(vector[...])",
3289 (Addr)vec[i].iov_base, vec[i].iov_len );
3294 /* ---------------------------------------------------------------------
3295 key retention service wrappers
3296 ------------------------------------------------------------------ */
3298 PRE(sys_request_key)
3300 PRINT("sys_request_key ( %#lx(%s), %#lx(%s), %#lx(%s), %ld )",
3301 ARG1,(char*)ARG1,ARG2,(char*)ARG2,ARG3,(char*)ARG3,ARG4);
3302 PRE_REG_READ4(long, "request_key",
3303 const char *, type, const char *, description,
3304 const char *, callout_info, vki_key_serial_t, keyring);
3305 PRE_MEM_RASCIIZ( "request_key(type)", ARG1);
3306 PRE_MEM_RASCIIZ( "request_key(description)", ARG2);
3307 if (ARG3 != (UWord)NULL)
3308 PRE_MEM_RASCIIZ( "request_key(callout_info)", ARG3);
3313 PRINT("sys_add_key ( %#lx(%s), %#lx(%s), %#lx, %ld, %ld )",
3314 ARG1,(char*)ARG1,ARG2,(char*)ARG2,ARG3,ARG4,ARG5);
3315 PRE_REG_READ5(long, "add_key",
3316 const char *, type, const char *, description,
3317 const void *, payload, vki_size_t, plen,
3318 vki_key_serial_t, keyring);
3319 PRE_MEM_RASCIIZ( "add_key(type)", ARG1);
3320 PRE_MEM_RASCIIZ( "add_key(description)", ARG2);
3321 if (ARG3 != (UWord)NULL)
3322 PRE_MEM_READ( "request_key(payload)", ARG3, ARG4);
3327 switch (ARG1 /* option */) {
3328 case VKI_KEYCTL_GET_KEYRING_ID:
3329 PRINT("sys_keyctl ( KEYCTL_GET_KEYRING_ID, %ld, %ld )", ARG2,ARG3);
3330 PRE_REG_READ3(long, "keyctl(KEYCTL_GET_KEYRING_ID)",
3331 int, option, vki_key_serial_t, id, int, create);
3333 case VKI_KEYCTL_JOIN_SESSION_KEYRING:
3334 PRINT("sys_keyctl ( KEYCTL_JOIN_SESSION_KEYRING, %#lx(%s) )", ARG2,(char*)ARG2);
3335 PRE_REG_READ2(long, "keyctl(KEYCTL_JOIN_SESSION_KEYRING)",
3336 int, option, const char *, name);
3337 if (ARG2 != (UWord)NULL)
3338 PRE_MEM_RASCIIZ("keyctl(KEYCTL_JOIN_SESSION_KEYRING, name)", ARG2);
3340 case VKI_KEYCTL_UPDATE:
3341 PRINT("sys_keyctl ( KEYCTL_UPDATE, %ld, %#lx, %ld )", ARG2,ARG3,ARG4);
3342 PRE_REG_READ4(long, "keyctl(KEYCTL_UPDATE)",
3343 int, option, vki_key_serial_t, key,
3344 const void *, payload, vki_size_t, plen);
3345 if (ARG3 != (UWord)NULL)
3346 PRE_MEM_READ("keyctl(KEYCTL_UPDATE, payload)", ARG3, ARG4);
3348 case VKI_KEYCTL_REVOKE:
3349 PRINT("sys_keyctl ( KEYCTL_REVOKE, %ld )", ARG2);
3350 PRE_REG_READ2(long, "keyctl(KEYCTL_REVOKE)",
3351 int, option, vki_key_serial_t, id);
3353 case VKI_KEYCTL_CHOWN:
3354 PRINT("sys_keyctl ( KEYCTL_CHOWN, %ld, %ld, %ld )", ARG2,ARG3,ARG4);
3355 PRE_REG_READ4(long, "keyctl(KEYCTL_CHOWN)",
3356 int, option, vki_key_serial_t, id,
3357 vki_uid_t, uid, vki_gid_t, gid);
3359 case VKI_KEYCTL_SETPERM:
3360 PRINT("sys_keyctl ( KEYCTL_SETPERM, %ld, %ld )", ARG2,ARG3);
3361 PRE_REG_READ3(long, "keyctl(KEYCTL_SETPERM)",
3362 int, option, vki_key_serial_t, id, vki_key_perm_t, perm);
3364 case VKI_KEYCTL_DESCRIBE:
3365 PRINT("sys_keyctl ( KEYCTL_DESCRIBE, %ld, %#lx, %ld )", ARG2,ARG3,ARG4);
3366 PRE_REG_READ4(long, "keyctl(KEYCTL_DESCRIBE)",
3367 int, option, vki_key_serial_t, id,
3368 char *, buffer, vki_size_t, buflen);
3369 if (ARG3 != (UWord)NULL)
3370 PRE_MEM_WRITE("keyctl(KEYCTL_DESCRIBE, buffer)", ARG3, ARG4);
3372 case VKI_KEYCTL_CLEAR:
3373 PRINT("sys_keyctl ( KEYCTL_CLEAR, %ld )", ARG2);
3374 PRE_REG_READ2(long, "keyctl(KEYCTL_CLEAR)",
3375 int, option, vki_key_serial_t, keyring);
3377 case VKI_KEYCTL_LINK:
3378 PRINT("sys_keyctl ( KEYCTL_LINK, %ld, %ld )", ARG2,ARG3);
3379 PRE_REG_READ3(long, "keyctl(KEYCTL_LINK)", int, option,
3380 vki_key_serial_t, keyring, vki_key_serial_t, key);
3382 case VKI_KEYCTL_UNLINK:
3383 PRINT("sys_keyctl ( KEYCTL_UNLINK, %ld, %ld )", ARG2,ARG3);
3384 PRE_REG_READ3(long, "keyctl(KEYCTL_UNLINK)", int, option,
3385 vki_key_serial_t, keyring, vki_key_serial_t, key);
3387 case VKI_KEYCTL_SEARCH:
3388 PRINT("sys_keyctl ( KEYCTL_SEARCH, %ld, %#lx(%s), %#lx(%s), %ld )",
3389 ARG2,ARG3,(char*)ARG3,ARG4,(char*)ARG4,ARG5);
3390 PRE_REG_READ5(long, "keyctl(KEYCTL_SEARCH)",
3391 int, option, vki_key_serial_t, keyring,
3392 const char *, type, const char *, description,
3393 vki_key_serial_t, destring);
3394 PRE_MEM_RASCIIZ("sys_keyctl(KEYCTL_SEARCH, type)", ARG3);
3395 PRE_MEM_RASCIIZ("sys_keyctl(KEYCTL_SEARCH, description)", ARG4);
3397 case VKI_KEYCTL_READ:
3398 PRINT("sys_keyctl ( KEYCTL_READ, %ld, %#lx, %ld )", ARG2,ARG3,ARG4);
3399 PRE_REG_READ4(long, "keyctl(KEYCTL_READ)",
3400 int, option, vki_key_serial_t, keyring,
3401 char *, buffer, vki_size_t, buflen);
3402 if (ARG3 != (UWord)NULL)
3403 PRE_MEM_WRITE("keyctl(KEYCTL_READ, buffer)", ARG3, ARG4);
3405 case VKI_KEYCTL_INSTANTIATE:
3406 PRINT("sys_keyctl ( KEYCTL_INSTANTIATE, %ld, %#lx, %ld, %ld )",
3407 ARG2,ARG3,ARG4,ARG5);
3408 PRE_REG_READ5(long, "keyctl(KEYCTL_INSTANTIATE)",
3409 int, option, vki_key_serial_t, key,
3410 char *, payload, vki_size_t, plen,
3411 vki_key_serial_t, keyring);
3412 if (ARG3 != (UWord)NULL)
3413 PRE_MEM_READ("keyctl(KEYCTL_INSTANTIATE, payload)", ARG3, ARG4);
3415 case VKI_KEYCTL_NEGATE:
3416 PRINT("sys_keyctl ( KEYCTL_NEGATE, %ld, %lu, %ld )", ARG2,ARG3,ARG4);
3417 PRE_REG_READ4(long, "keyctl(KEYCTL_NEGATE)",
3418 int, option, vki_key_serial_t, key,
3419 unsigned, timeout, vki_key_serial_t, keyring);
3421 case VKI_KEYCTL_SET_REQKEY_KEYRING:
3422 PRINT("sys_keyctl ( KEYCTL_SET_REQKEY_KEYRING, %ld )", ARG2);
3423 PRE_REG_READ2(long, "keyctl(KEYCTL_SET_REQKEY_KEYRING)",
3424 int, option, int, reqkey_defl);
3426 case VKI_KEYCTL_SET_TIMEOUT:
3427 PRINT("sys_keyctl ( KEYCTL_SET_TIMEOUT, %ld, %ld )", ARG2,ARG3);
3428 PRE_REG_READ3(long, "keyctl(KEYCTL_SET_TIMEOUT)",
3429 int, option, vki_key_serial_t, key, unsigned, timeout);
3431 case VKI_KEYCTL_ASSUME_AUTHORITY:
3432 PRINT("sys_keyctl ( KEYCTL_ASSUME_AUTHORITY, %ld )", ARG2);
3433 PRE_REG_READ2(long, "keyctl(KEYCTL_ASSUME_AUTHORITY)",
3434 int, option, vki_key_serial_t, key);
3437 PRINT("sys_keyctl ( %ld ) ", ARG1);
3438 PRE_REG_READ1(long, "keyctl", int, option);
3446 switch (ARG1 /* option */) {
3447 case VKI_KEYCTL_DESCRIBE:
3448 case VKI_KEYCTL_READ:
3450 POST_MEM_WRITE(ARG3, ARG4);
3452 POST_MEM_WRITE(ARG3, RES);
3459 /* ---------------------------------------------------------------------
3461 ------------------------------------------------------------------ */
3465 PRINT("sys_ioprio_set ( %ld, %ld, %ld )", ARG1,ARG2,ARG3);
3466 PRE_REG_READ3(int, "ioprio_set", int, which, int, who, int, ioprio);
3471 PRINT("sys_ioprio_get ( %ld, %ld )", ARG1,ARG2);
3472 PRE_REG_READ2(int, "ioprio_get", int, which, int, who);
3475 /* ---------------------------------------------------------------------
3477 ------------------------------------------------------------------ */
3479 PRE(sys_init_module)
3481 *flags |= SfMayBlock;
3482 PRINT("sys_init_module ( %#lx, %llu, %#lx(\"%s\") )",
3483 ARG1, (ULong)ARG2, ARG3, (char*)ARG3);
3484 PRE_REG_READ3(long, "init_module",
3485 void *, umod, unsigned long, len, const char *, uargs);
3486 PRE_MEM_READ( "init_module(umod)", ARG1, ARG2 );
3487 PRE_MEM_RASCIIZ( "init_module(uargs)", ARG3 );
3490 PRE(sys_delete_module)
3492 *flags |= SfMayBlock;
3493 PRINT("sys_delete_module ( %#lx(\"%s\"), 0x%lx )", ARG1,(char*)ARG1, ARG2);
3494 PRE_REG_READ2(long, "delete_module",
3495 const char *, name_user, unsigned int, flags);
3496 PRE_MEM_RASCIIZ("delete_module(name_user)", ARG1);
3499 /* ---------------------------------------------------------------------
3501 ------------------------------------------------------------------ */
3505 *flags |= SfMayBlock;
3506 PRINT("sys_splice ( %ld, %#lx, %ld, %#lx, %ld, %ld )",
3507 ARG1,ARG2,ARG3,ARG4,ARG5,ARG6);
3508 PRE_REG_READ6(int32_t, "splice",
3509 int, fd_in, vki_loff_t *, off_in,
3510 int, fd_out, vki_loff_t *, off_out,
3511 vki_size_t, len, unsigned int, flags);
3512 if (!ML_(fd_allowed)(ARG1, "splice(fd_in)", tid, False) ||
3513 !ML_(fd_allowed)(ARG3, "splice(fd_out)", tid, False)) {
3514 SET_STATUS_Failure( VKI_EBADF );
3517 PRE_MEM_READ( "splice(off_in)", ARG2, sizeof(vki_loff_t));
3519 PRE_MEM_READ( "splice(off_out)", ARG4, sizeof(vki_loff_t));
3523 /* ---------------------------------------------------------------------
3524 oprofile-related wrappers
3525 ------------------------------------------------------------------ */
3527 #if defined(VGP_x86_linux)
3528 PRE(sys_lookup_dcookie)
3530 PRINT("sys_lookup_dcookie (0x%llx, %#lx, %ld)",
3531 MERGE64(ARG1,ARG2), ARG3, ARG4);
3532 PRE_REG_READ4(long, "lookup_dcookie",
3533 vki_u32, MERGE64_FIRST(cookie), vki_u32, MERGE64_SECOND(cookie),
3534 char *, buf, vki_size_t, len);
3535 PRE_MEM_WRITE( "lookup_dcookie(buf)", ARG3, ARG4);
3537 POST(sys_lookup_dcookie)
3540 if (ARG3 != (Addr)NULL)
3541 POST_MEM_WRITE( ARG3, RES);
3545 #if defined(VGP_amd64_linux)
3546 PRE(sys_lookup_dcookie)
3548 *flags |= SfMayBlock;
3549 PRINT("sys_lookup_dcookie ( %llu, %#lx, %llu )",
3550 (ULong)ARG1, ARG2, (ULong)ARG3);
3551 PRE_REG_READ3(int, "lookup_dcookie",
3552 unsigned long long, cookie, char *, buf, vki_size_t, len);
3554 PRE_MEM_WRITE( "sys_lookup_dcookie(buf)", ARG2, ARG3 );
3557 POST(sys_lookup_dcookie)
3560 if (ARG2 != (Addr)NULL)
3561 POST_MEM_WRITE( ARG2, RES );
3565 /* ---------------------------------------------------------------------
3567 ------------------------------------------------------------------ */
3572 // These ones ignore ARG3.
3577 case VKI_F_GETLEASE:
3578 PRINT("sys_fcntl ( %ld, %ld )", ARG1,ARG2);
3579 PRE_REG_READ2(long, "fcntl", unsigned int, fd, unsigned int, cmd);
3582 // These ones use ARG3 as "arg".
3586 case VKI_F_SETLEASE:
3590 PRINT("sys_fcntl[ARG3=='arg'] ( %ld, %ld, %ld )", ARG1,ARG2,ARG3);
3591 PRE_REG_READ3(long, "fcntl",
3592 unsigned int, fd, unsigned int, cmd, unsigned long, arg);
3595 // These ones use ARG3 as "lock".
3599 # if defined(VGP_x86_linux)
3602 case VKI_F_SETLKW64:
3604 PRINT("sys_fcntl[ARG3=='lock'] ( %ld, %ld, %#lx )", ARG1,ARG2,ARG3);
3605 PRE_REG_READ3(long, "fcntl",
3606 unsigned int, fd, unsigned int, cmd,
3607 struct flock64 *, lock);
3611 PRINT("sys_fcntl[UNKNOWN] ( %ld, %ld, %ld )", ARG1,ARG2,ARG3);
3616 # if defined(VGP_x86_linux)
3617 if (ARG2 == VKI_F_SETLKW || ARG2 == VKI_F_SETLKW64)
3619 if (ARG2 == VKI_F_SETLKW)
3621 *flags |= SfMayBlock;
3627 if (ARG2 == VKI_F_DUPFD) {
3628 if (!ML_(fd_allowed)(RES, "fcntl(DUPFD)", tid, True)) {
3630 SET_STATUS_Failure( VKI_EMFILE );
3632 if (VG_(clo_track_fds))
3633 ML_(record_fd_open_named)(tid, RES);
3638 // XXX: wrapper only suitable for 32-bit systems
3642 // These ones ignore ARG3.
3649 case VKI_F_GETLEASE:
3650 PRINT("sys_fcntl64 ( %ld, %ld )", ARG1,ARG2);
3651 PRE_REG_READ2(long, "fcntl64", unsigned int, fd, unsigned int, cmd);
3654 // These ones use ARG3 as "arg".
3658 case VKI_F_SETLEASE:
3660 PRINT("sys_fcntl64[ARG3=='arg'] ( %ld, %ld, %ld )", ARG1,ARG2,ARG3);
3661 PRE_REG_READ3(long, "fcntl64",
3662 unsigned int, fd, unsigned int, cmd, unsigned long, arg);
3665 // These ones use ARG3 as "lock".
3669 # if defined(VGP_x86_linux)
3672 case VKI_F_SETLKW64:
3674 PRINT("sys_fcntl64[ARG3=='lock'] ( %ld, %ld, %#lx )", ARG1,ARG2,ARG3);
3675 PRE_REG_READ3(long, "fcntl64",
3676 unsigned int, fd, unsigned int, cmd,
3677 struct flock64 *, lock);
3681 # if defined(VGP_x86_linux)
3682 if (ARG2 == VKI_F_SETLKW || ARG2 == VKI_F_SETLKW64)
3684 if (ARG2 == VKI_F_SETLKW)
3686 *flags |= SfMayBlock;
3692 if (ARG2 == VKI_F_DUPFD) {
3693 if (!ML_(fd_allowed)(RES, "fcntl64(DUPFD)", tid, True)) {
3695 SET_STATUS_Failure( VKI_EMFILE );
3697 if (VG_(clo_track_fds))
3698 ML_(record_fd_open_named)(tid, RES);
3703 /* ---------------------------------------------------------------------
3705 ------------------------------------------------------------------ */
3709 *flags |= SfMayBlock;
3710 PRINT("sys_ioctl ( %ld, 0x%lx, %#lx )",ARG1,ARG2,ARG3);
3711 PRE_REG_READ3(long, "ioctl",
3712 unsigned int, fd, unsigned int, request, unsigned long, arg);
3714 // We first handle the ones that don't use ARG3 (even as a
3715 // scalar/non-pointer argument).
3716 switch (ARG2 /* request */) {
3718 /* linux/soundcard interface (ALSA) */
3719 case VKI_SNDRV_PCM_IOCTL_HW_FREE:
3720 case VKI_SNDRV_PCM_IOCTL_HWSYNC:
3721 case VKI_SNDRV_PCM_IOCTL_PREPARE:
3722 case VKI_SNDRV_PCM_IOCTL_RESET:
3723 case VKI_SNDRV_PCM_IOCTL_START:
3724 case VKI_SNDRV_PCM_IOCTL_DROP:
3725 case VKI_SNDRV_PCM_IOCTL_DRAIN:
3726 case VKI_SNDRV_PCM_IOCTL_RESUME:
3727 case VKI_SNDRV_PCM_IOCTL_XRUN:
3728 case VKI_SNDRV_PCM_IOCTL_UNLINK:
3729 case VKI_SNDRV_TIMER_IOCTL_START:
3730 case VKI_SNDRV_TIMER_IOCTL_STOP:
3731 case VKI_SNDRV_TIMER_IOCTL_CONTINUE:
3732 case VKI_SNDRV_TIMER_IOCTL_PAUSE:
3733 PRINT("sys_ioctl ( %ld, 0x%lx )",ARG1,ARG2);
3734 PRE_REG_READ2(long, "ioctl",
3735 unsigned int, fd, unsigned int, request);
3739 PRINT("sys_ioctl ( %ld, 0x%lx, 0x%lx )",ARG1,ARG2,ARG3);
3740 PRE_REG_READ3(long, "ioctl",
3741 unsigned int, fd, unsigned int, request, unsigned long, arg);
3745 // We now handle those that do look at ARG3 (and unknown ones fall into
3746 // this category). Nb: some of these may well belong in the
3747 // doesn't-use-ARG3 switch above.
3748 switch (ARG2 /* request */) {
3752 PRE_MEM_READ( "ioctl(TCSET{S,SW,SF})", ARG3, sizeof(struct vki_termios) );
3755 PRE_MEM_WRITE( "ioctl(TCGETS)", ARG3, sizeof(struct vki_termios) );
3760 PRE_MEM_READ( "ioctl(TCSET{A,AW,AF})", ARG3, sizeof(struct vki_termio) );
3763 PRE_MEM_WRITE( "ioctl(TCGETA)", ARG3, sizeof(struct vki_termio) );
3769 /* These just take an int by value */
3771 case VKI_TIOCGWINSZ:
3772 PRE_MEM_WRITE( "ioctl(TIOCGWINSZ)", ARG3, sizeof(struct vki_winsize) );
3774 case VKI_TIOCSWINSZ:
3775 PRE_MEM_READ( "ioctl(TIOCSWINSZ)", ARG3, sizeof(struct vki_winsize) );
3778 PRE_MEM_READ( "ioctl(TIOCMBIS)", ARG3, sizeof(unsigned int) );
3781 PRE_MEM_READ( "ioctl(TIOCMBIC)", ARG3, sizeof(unsigned int) );
3784 PRE_MEM_READ( "ioctl(TIOCMSET)", ARG3, sizeof(unsigned int) );
3787 PRE_MEM_WRITE( "ioctl(TIOCMGET)", ARG3, sizeof(unsigned int) );
3790 PRE_MEM_READ( "ioctl(TIOCLINUX)", ARG3, sizeof(char *) );
3791 if (*(char *)ARG3 == 11) {
3792 PRE_MEM_READ( "ioctl(TIOCLINUX, 11)", ARG3, 2 * sizeof(char *) );
3796 /* Get process group ID for foreground processing group. */
3797 PRE_MEM_WRITE( "ioctl(TIOCGPGRP)", ARG3, sizeof(vki_pid_t) );
3800 /* Set a process group ID? */
3801 PRE_MEM_WRITE( "ioctl(TIOCGPGRP)", ARG3, sizeof(vki_pid_t) );
3803 case VKI_TIOCGPTN: /* Get Pty Number (of pty-mux device) */
3804 PRE_MEM_WRITE( "ioctl(TIOCGPTN)", ARG3, sizeof(int) );
3807 /* Just takes an int value. */
3809 case VKI_TIOCSPTLCK: /* Lock/unlock Pty */
3810 PRE_MEM_READ( "ioctl(TIOCSPTLCK)", ARG3, sizeof(int) );
3813 PRE_MEM_READ( "ioctl(FIONBIO)", ARG3, sizeof(int) );
3816 PRE_MEM_READ( "ioctl(FIOASYNC)", ARG3, sizeof(int) );
3818 case VKI_FIONREAD: /* identical to SIOCINQ */
3819 PRE_MEM_WRITE( "ioctl(FIONREAD)", ARG3, sizeof(int) );
3822 case VKI_TIOCSERGETLSR:
3823 PRE_MEM_WRITE( "ioctl(TIOCSERGETLSR)", ARG3, sizeof(int) );
3825 case VKI_TIOCGICOUNT:
3826 PRE_MEM_WRITE( "ioctl(TIOCGICOUNT)", ARG3,
3827 sizeof(struct vki_serial_icounter_struct) );
3830 case VKI_SG_SET_COMMAND_Q:
3831 PRE_MEM_READ( "ioctl(SG_SET_COMMAND_Q)", ARG3, sizeof(int) );
3834 PRE_MEM_WRITE( "ioctl(SG_IO)", ARG3, sizeof(vki_sg_io_hdr_t) );
3836 case VKI_SG_GET_SCSI_ID:
3837 PRE_MEM_WRITE( "ioctl(SG_GET_SCSI_ID)", ARG3, sizeof(vki_sg_scsi_id_t) );
3839 case VKI_SG_SET_RESERVED_SIZE:
3840 PRE_MEM_READ( "ioctl(SG_SET_RESERVED_SIZE)", ARG3, sizeof(int) );
3842 case VKI_SG_SET_TIMEOUT:
3843 PRE_MEM_READ( "ioctl(SG_SET_TIMEOUT)", ARG3, sizeof(int) );
3845 case VKI_SG_GET_RESERVED_SIZE:
3846 PRE_MEM_WRITE( "ioctl(SG_GET_RESERVED_SIZE)", ARG3, sizeof(int) );
3848 case VKI_SG_GET_TIMEOUT:
3850 case VKI_SG_GET_VERSION_NUM:
3851 PRE_MEM_WRITE( "ioctl(SG_GET_VERSION_NUM)", ARG3, sizeof(int) );
3853 case VKI_SG_EMULATED_HOST: /* 0x2203 */
3854 PRE_MEM_WRITE( "ioctl(SG_EMULATED_HOST)", ARG3, sizeof(int) );
3856 case VKI_SG_GET_SG_TABLESIZE: /* 0x227f */
3857 PRE_MEM_WRITE( "ioctl(SG_GET_SG_TABLESIZE)", ARG3, sizeof(int) );
3860 case VKI_IIOCGETCPS:
3861 PRE_MEM_WRITE( "ioctl(IIOCGETCPS)", ARG3,
3862 VKI_ISDN_MAX_CHANNELS * 2 * sizeof(unsigned long) );
3864 case VKI_IIOCNETGPN:
3865 PRE_MEM_READ( "ioctl(IIOCNETGPN)",
3866 (Addr)&((vki_isdn_net_ioctl_phone *)ARG3)->name,
3867 sizeof(((vki_isdn_net_ioctl_phone *)ARG3)->name) );
3868 PRE_MEM_WRITE( "ioctl(IIOCNETGPN)", ARG3,
3869 sizeof(vki_isdn_net_ioctl_phone) );
3872 /* These all use struct ifreq AFAIK */
3873 case VKI_SIOCGIFINDEX: /* get iface index */
3874 PRE_MEM_RASCIIZ( "ioctl(SIOCGIFINDEX)",
3875 (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
3876 PRE_MEM_WRITE( "ioctl(SIOCGIFINDEX)", ARG3, sizeof(struct vki_ifreq));
3878 case VKI_SIOCGIFFLAGS: /* get flags */
3879 PRE_MEM_RASCIIZ( "ioctl(SIOCGIFFLAGS)",
3880 (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
3881 PRE_MEM_WRITE( "ioctl(SIOCGIFFLAGS)", ARG3, sizeof(struct vki_ifreq));
3883 case VKI_SIOCGIFHWADDR: /* Get hardware address */
3884 PRE_MEM_RASCIIZ( "ioctl(SIOCGIFHWADDR)",
3885 (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
3886 PRE_MEM_WRITE( "ioctl(SIOCGIFHWADDR)", ARG3, sizeof(struct vki_ifreq));
3888 case VKI_SIOCGIFMTU: /* get MTU size */
3889 PRE_MEM_RASCIIZ( "ioctl(SIOCGIFMTU)",
3890 (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
3891 PRE_MEM_WRITE( "ioctl(SIOCGIFMTU)", ARG3, sizeof(struct vki_ifreq));
3893 case VKI_SIOCGIFADDR: /* get PA address */
3894 PRE_MEM_RASCIIZ( "ioctl(SIOCGIFADDR)",
3895 (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
3896 PRE_MEM_WRITE( "ioctl(SIOCGIFADDR)", ARG3, sizeof(struct vki_ifreq));
3898 case VKI_SIOCGIFNETMASK: /* get network PA mask */
3899 PRE_MEM_RASCIIZ( "ioctl(SIOCGIFNETMASK)",
3900 (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
3901 PRE_MEM_WRITE( "ioctl(SIOCGIFNETMASK)", ARG3, sizeof(struct vki_ifreq));
3903 case VKI_SIOCGIFMETRIC: /* get metric */
3904 PRE_MEM_RASCIIZ( "ioctl(SIOCGIFMETRIC)",
3905 (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
3906 PRE_MEM_WRITE( "ioctl(SIOCGIFMETRIC)", ARG3, sizeof(struct vki_ifreq));
3908 case VKI_SIOCGIFMAP: /* Get device parameters */
3909 PRE_MEM_RASCIIZ( "ioctl(SIOCGIFMAP)",
3910 (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
3911 PRE_MEM_WRITE( "ioctl(SIOCGIFMAP)", ARG3, sizeof(struct vki_ifreq));
3913 case VKI_SIOCGIFTXQLEN: /* Get the tx queue length */
3914 PRE_MEM_RASCIIZ( "ioctl(SIOCGIFTXQLEN)",
3915 (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
3916 PRE_MEM_WRITE( "ioctl(SIOCGIFTXQLEN)", ARG3, sizeof(struct vki_ifreq));
3918 case VKI_SIOCGIFDSTADDR: /* get remote PA address */
3919 PRE_MEM_RASCIIZ( "ioctl(SIOCGIFDSTADDR)",
3920 (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
3921 PRE_MEM_WRITE( "ioctl(SIOCGIFDSTADDR)", ARG3, sizeof(struct vki_ifreq));
3923 case VKI_SIOCGIFBRDADDR: /* get broadcast PA address */
3924 PRE_MEM_RASCIIZ( "ioctl(SIOCGIFBRDADDR)",
3925 (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
3926 PRE_MEM_WRITE( "ioctl(SIOCGIFBRDADDR)", ARG3, sizeof(struct vki_ifreq));
3928 case VKI_SIOCGIFNAME: /* get iface name */
3929 PRE_MEM_READ( "ioctl(SIOCGIFNAME)",
3930 (Addr)&((struct vki_ifreq *)ARG3)->vki_ifr_ifindex,
3931 sizeof(((struct vki_ifreq *)ARG3)->vki_ifr_ifindex) );
3932 PRE_MEM_WRITE( "ioctl(SIOCGIFNAME)", ARG3, sizeof(struct vki_ifreq));
3934 case VKI_SIOCGMIIPHY: /* get hardware entry */
3935 PRE_MEM_RASCIIZ( "ioctl(SIOCGIFMIIPHY)",
3936 (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
3937 PRE_MEM_WRITE( "ioctl(SIOCGIFMIIPHY)", ARG3, sizeof(struct vki_ifreq));
3939 case VKI_SIOCGMIIREG: /* get hardware entry registers */
3940 PRE_MEM_RASCIIZ( "ioctl(SIOCGIFMIIREG)",
3941 (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
3942 PRE_MEM_READ( "ioctl(SIOCGIFMIIREG)",
3943 (Addr)&((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)ARG3)->vki_ifr_data)->phy_id,
3944 sizeof(((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)ARG3)->vki_ifr_data)->phy_id) );
3945 PRE_MEM_READ( "ioctl(SIOCGIFMIIREG)",
3946 (Addr)&((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)ARG3)->vki_ifr_data)->reg_num,
3947 sizeof(((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)ARG3)->vki_ifr_data)->reg_num) );
3948 PRE_MEM_WRITE( "ioctl(SIOCGIFMIIREG)", ARG3,
3949 sizeof(struct vki_ifreq));
3951 case VKI_SIOCGIFCONF: /* get iface list */
3953 PRE_MEM_WRITE( "ioctl(SIOCGIFCONF)", ARG3, sizeof(struct ifconf));
3954 KERNEL_DO_SYSCALL(tid,RES);
3955 if (!VG_(is_kerror)(RES) && RES == 0)
3956 POST_MEM_WRITE(ARG3, sizeof(struct ifconf));
3958 PRE_MEM_READ( "ioctl(SIOCGIFCONF)",
3959 (Addr)&((struct vki_ifconf *)ARG3)->ifc_len,
3960 sizeof(((struct vki_ifconf *)ARG3)->ifc_len));
3961 PRE_MEM_READ( "ioctl(SIOCGIFCONF)",
3962 (Addr)&((struct vki_ifconf *)ARG3)->vki_ifc_buf,
3963 sizeof(((struct vki_ifconf *)ARG3)->vki_ifc_buf));
3965 // TODO len must be readable and writable
3966 // buf pointer only needs to be readable
3967 struct vki_ifconf *ifc = (struct vki_ifconf *) ARG3;
3968 PRE_MEM_WRITE( "ioctl(SIOCGIFCONF).ifc_buf",
3969 (Addr)(ifc->vki_ifc_buf), ifc->ifc_len );
3972 case VKI_SIOCGSTAMP:
3973 PRE_MEM_WRITE( "ioctl(SIOCGSTAMP)", ARG3, sizeof(struct vki_timeval));
3975 case VKI_SIOCGSTAMPNS:
3976 PRE_MEM_WRITE( "ioctl(SIOCGSTAMPNS)", ARG3, sizeof(struct vki_timespec));
3978 /* SIOCOUTQ is an ioctl that, when called on a socket, returns
3979 the number of bytes currently in that socket's send buffer.
3980 It writes this value as an int to the memory location
3981 indicated by the third argument of ioctl(2). */
3983 PRE_MEM_WRITE( "ioctl(SIOCOUTQ)", ARG3, sizeof(int));
3985 case VKI_SIOCGRARP: /* get RARP table entry */
3986 case VKI_SIOCGARP: /* get ARP table entry */
3987 PRE_MEM_WRITE( "ioctl(SIOCGARP)", ARG3, sizeof(struct vki_arpreq));
3990 case VKI_SIOCSIFFLAGS: /* set flags */
3991 PRE_MEM_RASCIIZ( "ioctl(SIOCSIFFLAGS)",
3992 (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
3993 PRE_MEM_READ( "ioctl(SIOCSIFFLAGS)",
3994 (Addr)&((struct vki_ifreq *)ARG3)->vki_ifr_flags,
3995 sizeof(((struct vki_ifreq *)ARG3)->vki_ifr_flags) );
3997 case VKI_SIOCSIFMAP: /* Set device parameters */
3998 PRE_MEM_RASCIIZ( "ioctl(SIOCSIFMAP)",
3999 (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
4000 PRE_MEM_READ( "ioctl(SIOCSIFMAP)",
4001 (Addr)&((struct vki_ifreq *)ARG3)->ifr_map,
4002 sizeof(((struct vki_ifreq *)ARG3)->ifr_map) );
4004 case VKI_SIOCSIFTXQLEN: /* Set the tx queue length */
4005 PRE_MEM_RASCIIZ( "ioctl(SIOCSIFTXQLEN)",
4006 (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
4007 PRE_MEM_READ( "ioctl(SIOCSIFTXQLEN)",
4008 (Addr)&((struct vki_ifreq *)ARG3)->ifr_qlen,
4009 sizeof(((struct vki_ifreq *)ARG3)->ifr_qlen) );
4011 case VKI_SIOCSIFADDR: /* set PA address */
4012 case VKI_SIOCSIFDSTADDR: /* set remote PA address */
4013 case VKI_SIOCSIFBRDADDR: /* set broadcast PA address */
4014 case VKI_SIOCSIFNETMASK: /* set network PA mask */
4015 PRE_MEM_RASCIIZ( "ioctl(SIOCSIF*ADDR)",
4016 (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
4017 PRE_MEM_READ( "ioctl(SIOCSIF*ADDR)",
4018 (Addr)&((struct vki_ifreq *)ARG3)->ifr_addr,
4019 sizeof(((struct vki_ifreq *)ARG3)->ifr_addr) );
4021 case VKI_SIOCSIFMETRIC: /* set metric */
4022 PRE_MEM_RASCIIZ( "ioctl(SIOCSIFMETRIC)",
4023 (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
4024 PRE_MEM_READ( "ioctl(SIOCSIFMETRIC)",
4025 (Addr)&((struct vki_ifreq *)ARG3)->vki_ifr_metric,
4026 sizeof(((struct vki_ifreq *)ARG3)->vki_ifr_metric) );
4028 case VKI_SIOCSIFMTU: /* set MTU size */
4029 PRE_MEM_RASCIIZ( "ioctl(SIOCSIFMTU)",
4030 (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
4031 PRE_MEM_READ( "ioctl(SIOCSIFMTU)",
4032 (Addr)&((struct vki_ifreq *)ARG3)->vki_ifr_mtu,
4033 sizeof(((struct vki_ifreq *)ARG3)->vki_ifr_mtu) );
4035 case VKI_SIOCSIFHWADDR: /* set hardware address */
4036 PRE_MEM_RASCIIZ( "ioctl(SIOCSIFHWADDR)",
4037 (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
4038 PRE_MEM_READ( "ioctl(SIOCSIFHWADDR)",
4039 (Addr)&((struct vki_ifreq *)ARG3)->ifr_hwaddr,
4040 sizeof(((struct vki_ifreq *)ARG3)->ifr_hwaddr) );
4042 case VKI_SIOCSMIIREG: /* set hardware entry registers */
4043 PRE_MEM_RASCIIZ( "ioctl(SIOCSMIIREG)",
4044 (Addr)((struct vki_ifreq *)ARG3)->vki_ifr_name );
4045 PRE_MEM_READ( "ioctl(SIOCSMIIREG)",
4046 (Addr)&((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)ARG3)->vki_ifr_data)->phy_id,
4047 sizeof(((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)ARG3)->vki_ifr_data)->phy_id) );
4048 PRE_MEM_READ( "ioctl(SIOCSMIIREG)",
4049 (Addr)&((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)ARG3)->vki_ifr_data)->reg_num,
4050 sizeof(((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)ARG3)->vki_ifr_data)->reg_num) );
4051 PRE_MEM_READ( "ioctl(SIOCSMIIREG)",
4052 (Addr)&((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)ARG3)->vki_ifr_data)->val_in,
4053 sizeof(((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)ARG3)->vki_ifr_data)->val_in) );
4055 /* Routing table calls. */
4056 case VKI_SIOCADDRT: /* add routing table entry */
4057 case VKI_SIOCDELRT: /* delete routing table entry */
4058 PRE_MEM_READ( "ioctl(SIOCADDRT/DELRT)", ARG3,
4059 sizeof(struct vki_rtentry));
4062 /* RARP cache control calls. */
4063 case VKI_SIOCDRARP: /* delete RARP table entry */
4064 case VKI_SIOCSRARP: /* set RARP table entry */
4065 /* ARP cache control calls. */
4066 case VKI_SIOCSARP: /* set ARP table entry */
4067 case VKI_SIOCDARP: /* delete ARP table entry */
4068 PRE_MEM_READ( "ioctl(SIOCSIFFLAGS)", ARG3, sizeof(struct vki_ifreq));
4072 PRE_MEM_WRITE( "ioctl(SIOCGPGRP)", ARG3, sizeof(int) );
4075 PRE_MEM_READ( "ioctl(SIOCSPGRP)", ARG3, sizeof(int) );
4076 //tst->sys_flags &= ~SfMayBlock;
4079 /* linux/soundcard interface (OSS) */
4080 case VKI_SNDCTL_SEQ_GETOUTCOUNT:
4081 case VKI_SNDCTL_SEQ_GETINCOUNT:
4082 case VKI_SNDCTL_SEQ_PERCMODE:
4083 case VKI_SNDCTL_SEQ_TESTMIDI:
4084 case VKI_SNDCTL_SEQ_RESETSAMPLES:
4085 case VKI_SNDCTL_SEQ_NRSYNTHS:
4086 case VKI_SNDCTL_SEQ_NRMIDIS:
4087 case VKI_SNDCTL_SEQ_GETTIME:
4088 case VKI_SNDCTL_DSP_GETBLKSIZE:
4089 case VKI_SNDCTL_DSP_GETFMTS:
4090 case VKI_SNDCTL_DSP_GETTRIGGER:
4091 case VKI_SNDCTL_DSP_GETODELAY:
4092 case VKI_SNDCTL_DSP_GETSPDIF:
4093 case VKI_SNDCTL_DSP_GETCAPS:
4094 case VKI_SOUND_PCM_READ_RATE:
4095 case VKI_SOUND_PCM_READ_CHANNELS:
4096 case VKI_SOUND_PCM_READ_BITS:
4097 case VKI_SOUND_PCM_READ_FILTER:
4098 PRE_MEM_WRITE( "ioctl(SNDCTL_XXX|SOUND_XXX (SIOR, int))",
4101 case VKI_SNDCTL_SEQ_CTRLRATE:
4102 case VKI_SNDCTL_DSP_SPEED:
4103 case VKI_SNDCTL_DSP_STEREO:
4104 case VKI_SNDCTL_DSP_CHANNELS:
4105 case VKI_SOUND_PCM_WRITE_FILTER:
4106 case VKI_SNDCTL_DSP_SUBDIVIDE:
4107 case VKI_SNDCTL_DSP_SETFRAGMENT:
4108 case VKI_SNDCTL_DSP_SETFMT:
4109 case VKI_SNDCTL_DSP_GETCHANNELMASK:
4110 case VKI_SNDCTL_DSP_BIND_CHANNEL:
4111 case VKI_SNDCTL_TMR_TIMEBASE:
4112 case VKI_SNDCTL_TMR_TEMPO:
4113 case VKI_SNDCTL_TMR_SOURCE:
4114 case VKI_SNDCTL_MIDI_PRETIME:
4115 case VKI_SNDCTL_MIDI_MPUMODE:
4116 PRE_MEM_READ( "ioctl(SNDCTL_XXX|SOUND_XXX (SIOWR, int))",
4118 PRE_MEM_WRITE( "ioctl(SNDCTL_XXX|SOUND_XXX (SIOWR, int))",
4121 case VKI_SNDCTL_DSP_GETOSPACE:
4122 case VKI_SNDCTL_DSP_GETISPACE:
4123 PRE_MEM_WRITE( "ioctl(SNDCTL_XXX|SOUND_XXX (SIOR, audio_buf_info))",
4124 ARG3, sizeof(vki_audio_buf_info));
4126 case VKI_SNDCTL_DSP_NONBLOCK:
4128 case VKI_SNDCTL_DSP_SETTRIGGER:
4129 PRE_MEM_READ( "ioctl(SNDCTL_XXX|SOUND_XXX (SIOW, int))",
4133 case VKI_SNDCTL_DSP_POST:
4134 case VKI_SNDCTL_DSP_RESET:
4135 case VKI_SNDCTL_DSP_SYNC:
4136 case VKI_SNDCTL_DSP_SETSYNCRO:
4137 case VKI_SNDCTL_DSP_SETDUPLEX:
4140 /* linux/soundcard interface (ALSA) */
4141 case VKI_SNDRV_PCM_IOCTL_PAUSE:
4142 case VKI_SNDRV_PCM_IOCTL_LINK:
4143 /* these just take an int by value */
4146 /* Real Time Clock (/dev/rtc) ioctls */
4147 case VKI_RTC_UIE_ON:
4148 case VKI_RTC_UIE_OFF:
4149 case VKI_RTC_AIE_ON:
4150 case VKI_RTC_AIE_OFF:
4151 case VKI_RTC_PIE_ON:
4152 case VKI_RTC_PIE_OFF:
4153 case VKI_RTC_IRQP_SET:
4155 case VKI_RTC_RD_TIME:
4156 case VKI_RTC_ALM_READ:
4157 PRE_MEM_WRITE( "ioctl(RTC_RD_TIME/ALM_READ)",
4158 ARG3, sizeof(struct vki_rtc_time));
4160 case VKI_RTC_ALM_SET:
4161 PRE_MEM_READ( "ioctl(RTC_ALM_SET)", ARG3, sizeof(struct vki_rtc_time));
4163 case VKI_RTC_IRQP_READ:
4164 PRE_MEM_WRITE( "ioctl(RTC_IRQP_READ)", ARG3, sizeof(unsigned long));
4169 PRE_MEM_READ( "ioctl(BLKROSET)", ARG3, sizeof(int));
4172 PRE_MEM_WRITE( "ioctl(BLKROGET)", ARG3, sizeof(int));
4174 case VKI_BLKGETSIZE:
4175 PRE_MEM_WRITE( "ioctl(BLKGETSIZE)", ARG3, sizeof(unsigned long));
4180 PRE_MEM_WRITE( "ioctl(BLKRAGET)", ARG3, sizeof(long));
4185 PRE_MEM_WRITE( "ioctl(BLKFRAGET)", ARG3, sizeof(long));
4187 case VKI_BLKSECTGET:
4188 PRE_MEM_WRITE( "ioctl(BLKSECTGET)", ARG3, sizeof(unsigned short));
4191 PRE_MEM_WRITE( "ioctl(BLKSSZGET)", ARG3, sizeof(int));
4194 PRE_MEM_WRITE( "ioctl(BLKBSZGET)", ARG3, sizeof(int));
4197 PRE_MEM_READ( "ioctl(BLKBSZSET)", ARG3, sizeof(int));
4199 case VKI_BLKGETSIZE64:
4200 PRE_MEM_WRITE( "ioctl(BLKGETSIZE64)", ARG3, sizeof(unsigned long long));
4204 case VKI_HDIO_GETGEO: /* 0x0301 */
4205 PRE_MEM_WRITE( "ioctl(HDIO_GETGEO)", ARG3, sizeof(struct vki_hd_geometry));
4207 case VKI_HDIO_GET_DMA: /* 0x030b */
4208 PRE_MEM_WRITE( "ioctl(HDIO_GET_DMA)", ARG3, sizeof(long));
4210 case VKI_HDIO_GET_IDENTITY: /* 0x030d */
4211 PRE_MEM_WRITE( "ioctl(HDIO_GET_IDENTITY)", ARG3,
4212 VKI_SIZEOF_STRUCT_HD_DRIVEID );
4215 /* CD ROM stuff (??) */
4216 case VKI_CDROM_GET_MCN:
4217 PRE_MEM_READ( "ioctl(CDROM_GET_MCN)", ARG3,
4218 sizeof(struct vki_cdrom_mcn) );
4220 case VKI_CDROM_SEND_PACKET:
4221 PRE_MEM_READ( "ioctl(CDROM_SEND_PACKET)", ARG3,
4222 sizeof(struct vki_cdrom_generic_command));
4224 case VKI_CDROMSUBCHNL:
4225 PRE_MEM_READ( "ioctl(CDROMSUBCHNL (cdsc_format, char))",
4226 (Addr) &(((struct vki_cdrom_subchnl*) ARG3)->cdsc_format),
4227 sizeof(((struct vki_cdrom_subchnl*) ARG3)->cdsc_format));
4228 PRE_MEM_WRITE( "ioctl(CDROMSUBCHNL)", ARG3,
4229 sizeof(struct vki_cdrom_subchnl));
4231 case VKI_CDROMREADMODE2:
4232 PRE_MEM_READ( "ioctl(CDROMREADMODE2)", ARG3, VKI_CD_FRAMESIZE_RAW0 );
4234 case VKI_CDROMREADTOCHDR:
4235 PRE_MEM_WRITE( "ioctl(CDROMREADTOCHDR)", ARG3,
4236 sizeof(struct vki_cdrom_tochdr));
4238 case VKI_CDROMREADTOCENTRY:
4239 PRE_MEM_READ( "ioctl(CDROMREADTOCENTRY (cdte_format, char))",
4240 (Addr) &(((struct vki_cdrom_tocentry*) ARG3)->cdte_format),
4241 sizeof(((struct vki_cdrom_tocentry*) ARG3)->cdte_format));
4242 PRE_MEM_READ( "ioctl(CDROMREADTOCENTRY (cdte_track, char))",
4243 (Addr) &(((struct vki_cdrom_tocentry*) ARG3)->cdte_track),
4244 sizeof(((struct vki_cdrom_tocentry*) ARG3)->cdte_track));
4245 PRE_MEM_WRITE( "ioctl(CDROMREADTOCENTRY)", ARG3,
4246 sizeof(struct vki_cdrom_tocentry));
4248 case VKI_CDROMMULTISESSION: /* 0x5310 */
4249 PRE_MEM_WRITE( "ioctl(CDROMMULTISESSION)", ARG3,
4250 sizeof(struct vki_cdrom_multisession));
4252 case VKI_CDROMVOLREAD: /* 0x5313 */
4253 PRE_MEM_WRITE( "ioctl(CDROMVOLREAD)", ARG3,
4254 sizeof(struct vki_cdrom_volctrl));
4256 case VKI_CDROMREADRAW: /* 0x5314 */
4257 PRE_MEM_READ( "ioctl(CDROMREADRAW)", ARG3, sizeof(struct vki_cdrom_msf));
4258 PRE_MEM_WRITE( "ioctl(CDROMREADRAW)", ARG3, VKI_CD_FRAMESIZE_RAW);
4260 case VKI_CDROMREADAUDIO: /* 0x530e */
4261 PRE_MEM_READ( "ioctl(CDROMREADAUDIO)", ARG3,
4262 sizeof (struct vki_cdrom_read_audio));
4264 /* ToDo: don't do any of the following if the structure is invalid */
4265 struct vki_cdrom_read_audio *cra = (struct vki_cdrom_read_audio *) ARG3;
4266 PRE_MEM_WRITE( "ioctl(CDROMREADAUDIO).buf",
4267 (Addr)(cra->buf), cra->nframes * VKI_CD_FRAMESIZE_RAW);
4270 case VKI_CDROMPLAYMSF:
4271 PRE_MEM_READ( "ioctl(CDROMPLAYMSF)", ARG3, sizeof(struct vki_cdrom_msf));
4273 /* The following two are probably bogus (should check args
4274 for readability). JRS 20021117 */
4275 case VKI_CDROM_DRIVE_STATUS: /* 0x5326 */
4276 case VKI_CDROM_CLEAR_OPTIONS: /* 0x5321 */
4280 PRE_MEM_WRITE( "ioctl(FIGETBSZ)", ARG3, sizeof(unsigned long));
4283 PRE_MEM_READ( "ioctl(FIBMAP)", ARG3, sizeof(unsigned long));
4286 case VKI_FBIOGET_VSCREENINFO: /* 0x4600 */
4287 PRE_MEM_WRITE( "ioctl(FBIOGET_VSCREENINFO)", ARG3,
4288 sizeof(struct vki_fb_var_screeninfo));
4290 case VKI_FBIOGET_FSCREENINFO: /* 0x4602 */
4291 PRE_MEM_WRITE( "ioctl(FBIOGET_FSCREENINFO)", ARG3,
4292 sizeof(struct vki_fb_fix_screeninfo));
4301 PRE_MEM_READ( "ioctl(PPSETMODE)", ARG3, sizeof(int) );
4304 PRE_MEM_WRITE( "ioctl(PPGETMODE)", ARG3, sizeof(int) );
4306 case VKI_PPSETPHASE:
4307 PRE_MEM_READ( "ioctl(PPSETPHASE)", ARG3, sizeof(int) );
4309 case VKI_PPGETPHASE:
4310 PRE_MEM_WRITE( "ioctl(PPGETPHASE)", ARG3, sizeof(int) );
4312 case VKI_PPGETMODES:
4313 PRE_MEM_WRITE( "ioctl(PPGETMODES)", ARG3, sizeof(unsigned int) );
4315 case VKI_PPSETFLAGS:
4316 PRE_MEM_READ( "ioctl(PPSETFLAGS)", ARG3, sizeof(int) );
4318 case VKI_PPGETFLAGS:
4319 PRE_MEM_WRITE( "ioctl(PPGETFLAGS)", ARG3, sizeof(int) );
4322 PRE_MEM_WRITE( "ioctl(PPRSTATUS)", ARG3, sizeof(unsigned char) );
4325 PRE_MEM_WRITE( "ioctl(PPRDATA)", ARG3, sizeof(unsigned char) );
4327 case VKI_PPRCONTROL:
4328 PRE_MEM_WRITE( "ioctl(PPRCONTROL)", ARG3, sizeof(unsigned char) );
4331 PRE_MEM_READ( "ioctl(PPWDATA)", ARG3, sizeof(unsigned char) );
4333 case VKI_PPWCONTROL:
4334 PRE_MEM_READ( "ioctl(PPWCONTROL)", ARG3, sizeof(unsigned char) );
4336 case VKI_PPFCONTROL:
4337 PRE_MEM_READ( "ioctl(PPFCONTROL)", ARG3, 2 * sizeof(unsigned char) );
4340 PRE_MEM_READ( "ioctl(PPDATADIR)", ARG3, sizeof(int) );
4343 PRE_MEM_READ( "ioctl(PPNEGOT)", ARG3, sizeof(int) );
4345 case VKI_PPWCTLONIRQ:
4346 PRE_MEM_READ( "ioctl(PPWCTLONIRQ)",ARG3, sizeof(unsigned char) );
4349 PRE_MEM_WRITE( "ioctl(PPCLRIRQ)", ARG3, sizeof(int) );
4352 PRE_MEM_READ( "ioctl(PPSETTIME)", ARG3, sizeof(struct vki_timeval) );
4355 PRE_MEM_WRITE( "ioctl(PPGETTIME)", ARG3, sizeof(struct vki_timeval) );
4359 PRE_MEM_WRITE( "ioctl(GIO_FONT)", ARG3, 32 * 256 );
4362 PRE_MEM_READ( "ioctl(PIO_FONT)", ARG3, 32 * 256 );
4366 PRE_MEM_READ( "ioctl(GIO_FONTX)", ARG3, sizeof(struct vki_consolefontdesc) );
4368 /* ToDo: don't do any of the following if the structure is invalid */
4369 struct vki_consolefontdesc *cfd = (struct vki_consolefontdesc *)ARG3;
4370 PRE_MEM_WRITE( "ioctl(GIO_FONTX).chardata", (Addr)cfd->chardata,
4371 32 * cfd->charcount );
4375 PRE_MEM_READ( "ioctl(PIO_FONTX)", ARG3, sizeof(struct vki_consolefontdesc) );
4377 /* ToDo: don't do any of the following if the structure is invalid */
4378 struct vki_consolefontdesc *cfd = (struct vki_consolefontdesc *)ARG3;
4379 PRE_MEM_READ( "ioctl(PIO_FONTX).chardata", (Addr)cfd->chardata,
4380 32 * cfd->charcount );
4384 case VKI_PIO_FONTRESET:
4388 PRE_MEM_WRITE( "ioctl(GIO_CMAP)", ARG3, 16 * 3 );
4391 PRE_MEM_READ( "ioctl(PIO_CMAP)", ARG3, 16 * 3 );
4399 PRE_MEM_WRITE( "ioctl(KDGETLED)", ARG3, sizeof(char) );
4405 PRE_MEM_WRITE( "ioctl(KDGKBTYPE)", ARG3, sizeof(char) );
4417 PRE_MEM_WRITE( "ioctl(KDGETMODE)", ARG3, sizeof(int) );
4421 case VKI_KDUNMAPDISP:
4424 case VKI_GIO_SCRNMAP:
4425 PRE_MEM_WRITE( "ioctl(GIO_SCRNMAP)", ARG3, VKI_E_TABSZ );
4427 case VKI_PIO_SCRNMAP:
4428 PRE_MEM_READ( "ioctl(PIO_SCRNMAP)", ARG3, VKI_E_TABSZ );
4430 case VKI_GIO_UNISCRNMAP:
4431 PRE_MEM_WRITE( "ioctl(GIO_UNISCRNMAP)", ARG3,
4432 VKI_E_TABSZ * sizeof(unsigned short) );
4434 case VKI_PIO_UNISCRNMAP:
4435 PRE_MEM_READ( "ioctl(PIO_UNISCRNMAP)", ARG3,
4436 VKI_E_TABSZ * sizeof(unsigned short) );
4439 case VKI_GIO_UNIMAP:
4441 struct vki_unimapdesc *desc = (struct vki_unimapdesc *) ARG3;
4442 PRE_MEM_READ( "ioctl(GIO_UNIMAP)", (Addr)&desc->entry_ct,
4443 sizeof(unsigned short));
4444 PRE_MEM_READ( "ioctl(GIO_UNIMAP)", (Addr)&desc->entries,
4445 sizeof(struct vki_unipair *));
4446 PRE_MEM_WRITE( "ioctl(GIO_UNIMAP).entries", (Addr)desc->entries,
4447 desc->entry_ct * sizeof(struct vki_unipair));
4450 case VKI_PIO_UNIMAP:
4452 struct vki_unimapdesc *desc = (struct vki_unimapdesc *) ARG3;
4453 PRE_MEM_READ( "ioctl(GIO_UNIMAP)", (Addr)&desc->entry_ct,
4454 sizeof(unsigned short) );
4455 PRE_MEM_READ( "ioctl(GIO_UNIMAP)", (Addr)&desc->entries,
4456 sizeof(struct vki_unipair *) );
4457 PRE_MEM_READ( "ioctl(PIO_UNIMAP).entries", (Addr)desc->entries,
4458 desc->entry_ct * sizeof(struct vki_unipair) );
4461 case VKI_PIO_UNIMAPCLR:
4462 PRE_MEM_READ( "ioctl(GIO_UNIMAP)", ARG3, sizeof(struct vki_unimapinit));
4466 PRE_MEM_WRITE( "ioctl(KDGKBMODE)", ARG3, sizeof(int) );
4472 PRE_MEM_WRITE( "ioctl(KDGKBMETA)", ARG3, sizeof(int) );
4478 PRE_MEM_WRITE( "ioctl(KDGKBLED)", ARG3, sizeof(char) );
4484 PRE_MEM_READ( "ioctl(KDGKBENT).kb_table",
4485 (Addr)&((struct vki_kbentry *)ARG3)->kb_table,
4486 sizeof(((struct vki_kbentry *)ARG3)->kb_table) );
4487 PRE_MEM_READ( "ioctl(KDGKBENT).kb_index",
4488 (Addr)&((struct vki_kbentry *)ARG3)->kb_index,
4489 sizeof(((struct vki_kbentry *)ARG3)->kb_index) );
4490 PRE_MEM_WRITE( "ioctl(KDGKBENT).kb_value",
4491 (Addr)&((struct vki_kbentry *)ARG3)->kb_value,
4492 sizeof(((struct vki_kbentry *)ARG3)->kb_value) );
4495 PRE_MEM_READ( "ioctl(KDSKBENT).kb_table",
4496 (Addr)&((struct vki_kbentry *)ARG3)->kb_table,
4497 sizeof(((struct vki_kbentry *)ARG3)->kb_table) );
4498 PRE_MEM_READ( "ioctl(KDSKBENT).kb_index",
4499 (Addr)&((struct vki_kbentry *)ARG3)->kb_index,
4500 sizeof(((struct vki_kbentry *)ARG3)->kb_index) );
4501 PRE_MEM_READ( "ioctl(KDSKBENT).kb_value",
4502 (Addr)&((struct vki_kbentry *)ARG3)->kb_value,
4503 sizeof(((struct vki_kbentry *)ARG3)->kb_value) );
4507 PRE_MEM_READ( "ioctl(KDGKBSENT).kb_func",
4508 (Addr)&((struct vki_kbsentry *)ARG3)->kb_func,
4509 sizeof(((struct vki_kbsentry *)ARG3)->kb_func) );
4510 PRE_MEM_WRITE( "ioctl(KDGKSENT).kb_string",
4511 (Addr)((struct vki_kbsentry *)ARG3)->kb_string,
4512 sizeof(((struct vki_kbsentry *)ARG3)->kb_string) );
4515 PRE_MEM_READ( "ioctl(KDSKBSENT).kb_func",
4516 (Addr)&((struct vki_kbsentry *)ARG3)->kb_func,
4517 sizeof(((struct vki_kbsentry *)ARG3)->kb_func) );
4518 PRE_MEM_RASCIIZ( "ioctl(KDSKBSENT).kb_string",
4519 (Addr)((struct vki_kbsentry *)ARG3)->kb_string );
4522 case VKI_KDGKBDIACR:
4523 PRE_MEM_WRITE( "ioctl(KDGKBDIACR)", ARG3, sizeof(struct vki_kbdiacrs) );
4525 case VKI_KDSKBDIACR:
4526 PRE_MEM_READ( "ioctl(KDSKBDIACR)", ARG3, sizeof(struct vki_kbdiacrs) );
4529 case VKI_KDGETKEYCODE:
4530 PRE_MEM_READ( "ioctl(KDGETKEYCODE).scancode",
4531 (Addr)&((struct vki_kbkeycode *)ARG3)->scancode,
4532 sizeof(((struct vki_kbkeycode *)ARG3)->scancode) );
4533 PRE_MEM_WRITE( "ioctl(KDGETKEYCODE).keycode",
4534 (Addr)((struct vki_kbkeycode *)ARG3)->keycode,
4535 sizeof(((struct vki_kbkeycode *)ARG3)->keycode) );
4537 case VKI_KDSETKEYCODE:
4538 PRE_MEM_READ( "ioctl(KDSETKEYCODE).scancode",
4539 (Addr)&((struct vki_kbkeycode *)ARG3)->scancode,
4540 sizeof(((struct vki_kbkeycode *)ARG3)->scancode) );
4541 PRE_MEM_READ( "ioctl(KDSETKEYCODE).keycode",
4542 (Addr)((struct vki_kbkeycode *)ARG3)->keycode,
4543 sizeof(((struct vki_kbkeycode *)ARG3)->keycode) );
4546 case VKI_KDSIGACCEPT:
4550 PRE_MEM_READ( "ioctl(KBKBDREP)", ARG3, sizeof(struct vki_kbd_repeat) );
4555 struct vki_console_font_op *op = (struct vki_console_font_op *) ARG3;
4556 PRE_MEM_READ( "ioctl(KDFONTOP)", (Addr)op,
4557 sizeof(struct vki_console_font_op) );
4559 case VKI_KD_FONT_OP_SET:
4560 PRE_MEM_READ( "ioctl(KDFONTOP,KD_FONT_OP_SET).data",
4562 (op->width + 7) / 8 * 32 * op->charcount );
4564 case VKI_KD_FONT_OP_GET:
4566 PRE_MEM_WRITE( "ioctl(KDFONTOP,KD_FONT_OP_GET).data",
4568 (op->width + 7) / 8 * 32 * op->charcount );
4570 case VKI_KD_FONT_OP_SET_DEFAULT:
4572 PRE_MEM_RASCIIZ( "ioctl(KDFONTOP,KD_FONT_OP_SET_DEFAULT).data",
4575 case VKI_KD_FONT_OP_COPY:
4581 case VKI_VT_OPENQRY:
4582 PRE_MEM_WRITE( "ioctl(VT_OPENQRY)", ARG3, sizeof(int) );
4584 case VKI_VT_GETMODE:
4585 PRE_MEM_WRITE( "ioctl(VT_GETMODE)", ARG3, sizeof(struct vki_vt_mode) );
4587 case VKI_VT_SETMODE:
4588 PRE_MEM_READ( "ioctl(VT_SETMODE)", ARG3, sizeof(struct vki_vt_mode) );
4590 case VKI_VT_GETSTATE:
4591 PRE_MEM_WRITE( "ioctl(VT_GETSTATE).v_active",
4592 (Addr) &(((struct vki_vt_stat*) ARG3)->v_active),
4593 sizeof(((struct vki_vt_stat*) ARG3)->v_active));
4594 PRE_MEM_WRITE( "ioctl(VT_GETSTATE).v_state",
4595 (Addr) &(((struct vki_vt_stat*) ARG3)->v_state),
4596 sizeof(((struct vki_vt_stat*) ARG3)->v_state));
4598 case VKI_VT_RELDISP:
4599 case VKI_VT_ACTIVATE:
4600 case VKI_VT_WAITACTIVE:
4601 case VKI_VT_DISALLOCATE:
4604 PRE_MEM_READ( "ioctl(VT_RESIZE)", ARG3, sizeof(struct vki_vt_sizes) );
4606 case VKI_VT_RESIZEX:
4607 PRE_MEM_READ( "ioctl(VT_RESIZEX)", ARG3, sizeof(struct vki_vt_consize) );
4609 case VKI_VT_LOCKSWITCH:
4610 case VKI_VT_UNLOCKSWITCH:
4613 case VKI_USBDEVFS_CONTROL:
4615 struct vki_usbdevfs_ctrltransfer *vkuc = (struct vki_usbdevfs_ctrltransfer *)ARG3;
4616 PRE_MEM_READ( "ioctl(USBDEVFS_CONTROL).bRequestType", (Addr)&vkuc->bRequestType, sizeof(vkuc->bRequestType));
4617 PRE_MEM_READ( "ioctl(USBDEVFS_CONTROL).bRequest", (Addr)&vkuc->bRequest, sizeof(vkuc->bRequest));
4618 PRE_MEM_READ( "ioctl(USBDEVFS_CONTROL).wValue", (Addr)&vkuc->wValue, sizeof(vkuc->wValue));
4619 PRE_MEM_READ( "ioctl(USBDEVFS_CONTROL).wIndex", (Addr)&vkuc->wIndex, sizeof(vkuc->wIndex));
4620 PRE_MEM_READ( "ioctl(USBDEVFS_CONTROL).wLength", (Addr)&vkuc->wLength, sizeof(vkuc->wLength));
4621 PRE_MEM_READ( "ioctl(USBDEVFS_CONTROL).timeout", (Addr)&vkuc->timeout, sizeof(vkuc->timeout));
4622 if (vkuc->bRequestType & 0x80)
4623 PRE_MEM_WRITE( "ioctl(USBDEVFS_CONTROL).data", (Addr)vkuc->data, vkuc->wLength);
4625 PRE_MEM_READ( "ioctl(USBDEVFS_CONTROL).data", (Addr)vkuc->data, vkuc->wLength);
4628 case VKI_USBDEVFS_BULK:
4630 struct vki_usbdevfs_bulktransfer *vkub = (struct vki_usbdevfs_bulktransfer *)ARG3;
4631 PRE_MEM_READ( "ioctl(USBDEVFS_BULK)", ARG3, sizeof(struct vki_usbdevfs_bulktransfer));
4632 if (vkub->ep & 0x80)
4633 PRE_MEM_WRITE( "ioctl(USBDEVFS_BULK).data", (Addr)vkub->data, vkub->len);
4635 PRE_MEM_READ( "ioctl(USBDEVFS_BULK).data", (Addr)vkub->data, vkub->len);
4638 case VKI_USBDEVFS_GETDRIVER:
4640 struct vki_usbdevfs_getdriver *vkugd = (struct vki_usbdevfs_getdriver *) ARG3;
4641 PRE_MEM_WRITE( "ioctl(USBDEVFS_GETDRIVER)", (Addr)&vkugd->driver, sizeof(vkugd->driver));
4644 case VKI_USBDEVFS_SUBMITURB:
4646 struct vki_usbdevfs_urb *vkuu = (struct vki_usbdevfs_urb *)ARG3;
4648 /* Not the whole struct needs to be initialized */
4649 PRE_MEM_READ( "ioctl(USBDEVFS_SUBMITURB).endpoint", (Addr)&vkuu->endpoint, sizeof(vkuu->endpoint));
4650 PRE_MEM_READ( "ioctl(USBDEVFS_SUBMITURB).type", (Addr)&vkuu->type, sizeof(vkuu->type));
4651 PRE_MEM_READ( "ioctl(USBDEVFS_SUBMITURB).flags", (Addr)&vkuu->flags, sizeof(vkuu->flags));
4652 PRE_MEM_READ( "ioctl(USBDEVFS_SUBMITURB).buffer", (Addr)&vkuu->buffer, sizeof(vkuu->buffer));
4653 PRE_MEM_READ( "ioctl(USBDEVFS_SUBMITURB).signr", (Addr)&vkuu->signr, sizeof(vkuu->signr));
4654 PRE_MEM_WRITE( "ioctl(USBDEVFS_SUBMITURB).status", (Addr)&vkuu->status, sizeof(vkuu->status));
4655 if (vkuu->type == VKI_USBDEVFS_URB_TYPE_CONTROL) {
4656 struct vki_usbdevfs_setuppacket *vkusp = (struct vki_usbdevfs_setuppacket *)vkuu->buffer;
4657 PRE_MEM_READ( "ioctl(USBDEVFS_SUBMITURB).buffer_length", (Addr)&vkuu->buffer_length, sizeof(vkuu->buffer_length));
4658 PRE_MEM_READ( "ioctl(USBDEVFS_SUBMITURB).buffer.setup_packet", (Addr)vkusp, sizeof(*vkusp));
4659 if (vkusp->bRequestType & 0x80)
4660 PRE_MEM_WRITE( "ioctl(USBDEVFS_SUBMITURB).buffer.data", (Addr)(vkusp+1), vkuu->buffer_length - sizeof(*vkusp));
4662 PRE_MEM_READ( "ioctl(USBDEVFS_SUBMITURB).buffer.data", (Addr)(vkusp+1), vkuu->buffer_length - sizeof(*vkusp));
4663 PRE_MEM_WRITE( "ioctl(USBDEVFS_SUBMITURB).actual_length", (Addr)&vkuu->actual_length, sizeof(vkuu->actual_length));
4664 } else if (vkuu->type == VKI_USBDEVFS_URB_TYPE_ISO) {
4665 int total_length = 0;
4667 PRE_MEM_READ( "ioctl(USBDEVFS_SUBMITURB).number_of_packets", (Addr)&vkuu->number_of_packets, sizeof(vkuu->number_of_packets));
4668 for(i=0; i<vkuu->number_of_packets; i++) {
4669 PRE_MEM_READ( "ioctl(USBDEVFS_SUBMITURB).iso_frame_desc[].length", (Addr)&vkuu->iso_frame_desc[i].length, sizeof(vkuu->iso_frame_desc[i].length));
4670 PRE_MEM_WRITE( "ioctl(USBDEVFS_SUBMITURB).iso_frame_desc[].actual_length", (Addr)&vkuu->iso_frame_desc[i].actual_length, sizeof(vkuu->iso_frame_desc[i].actual_length));
4671 PRE_MEM_WRITE( "ioctl(USBDEVFS_SUBMITURB).iso_frame_desc[].status", (Addr)&vkuu->iso_frame_desc[i].status, sizeof(vkuu->iso_frame_desc[i].status));
4672 total_length += vkuu->iso_frame_desc[i].length;
4674 if (vkuu->endpoint & 0x80)
4675 PRE_MEM_WRITE( "ioctl(USBDEVFS_SUBMITURB).buffer", (Addr)vkuu->buffer, total_length);
4677 PRE_MEM_READ( "ioctl(USBDEVFS_SUBMITURB).buffer", (Addr)vkuu->buffer, total_length);
4678 PRE_MEM_WRITE( "ioctl(USBDEVFS_SUBMITURB).error_count", (Addr)&vkuu->error_count, sizeof(vkuu->error_count));
4680 PRE_MEM_READ( "ioctl(USBDEVFS_SUBMITURB).buffer_length", (Addr)&vkuu->buffer_length, sizeof(vkuu->buffer_length));
4681 if (vkuu->endpoint & 0x80)
4682 PRE_MEM_WRITE( "ioctl(USBDEVFS_SUBMITURB).buffer", (Addr)vkuu->buffer, vkuu->buffer_length);
4684 PRE_MEM_READ( "ioctl(USBDEVFS_SUBMITURB).buffer", (Addr)vkuu->buffer, vkuu->buffer_length);
4685 PRE_MEM_WRITE( "ioctl(USBDEVFS_SUBMITURB).actual_length", (Addr)&vkuu->actual_length, sizeof(vkuu->actual_length));
4689 case VKI_USBDEVFS_DISCARDURB:
4691 case VKI_USBDEVFS_REAPURB:
4693 PRE_MEM_WRITE( "ioctl(USBDEVFS_REAPURB)", ARG3, sizeof(struct vki_usbdevfs_urb **));
4696 case VKI_USBDEVFS_REAPURBNDELAY:
4698 PRE_MEM_WRITE( "ioctl(USBDEVFS_REAPURBNDELAY)", ARG3, sizeof(struct vki_usbdevfs_urb **));
4701 case VKI_USBDEVFS_CONNECTINFO:
4702 PRE_MEM_WRITE( "ioctl(USBDEVFS_CONNECTINFO)", ARG3, sizeof(struct vki_usbdevfs_connectinfo));
4704 case VKI_USBDEVFS_IOCTL:
4706 struct vki_usbdevfs_ioctl *vkui = (struct vki_usbdevfs_ioctl *)ARG3;
4708 PRE_MEM_READ("ioctl(USBDEVFS_IOCTL)", (Addr)vkui, sizeof(struct vki_usbdevfs_ioctl));
4709 dir2 = _VKI_IOC_DIR(vkui->ioctl_code);
4710 size2 = _VKI_IOC_SIZE(vkui->ioctl_code);
4712 if (dir2 & _VKI_IOC_WRITE)
4713 PRE_MEM_READ("ioctl(USBDEVFS_IOCTL).dataWrite", (Addr)vkui->data, size2);
4714 else if (dir2 & _VKI_IOC_READ)
4715 PRE_MEM_WRITE("ioctl(USBDEVFS_IOCTL).dataRead", (Addr)vkui->data, size2);
4720 /* I2C (/dev/i2c-*) ioctls */
4722 case VKI_I2C_SLAVE_FORCE:
4723 case VKI_I2C_TENBIT:
4727 PRE_MEM_WRITE( "ioctl(I2C_FUNCS)", ARG3, sizeof(unsigned long) );
4730 /* Wireless extensions ioctls */
4731 case VKI_SIOCSIWCOMMIT:
4732 case VKI_SIOCSIWNWID:
4733 case VKI_SIOCSIWFREQ:
4734 case VKI_SIOCSIWMODE:
4735 case VKI_SIOCSIWSENS:
4736 case VKI_SIOCSIWRANGE:
4737 case VKI_SIOCSIWPRIV:
4738 case VKI_SIOCSIWSTATS:
4739 case VKI_SIOCSIWSPY:
4740 case VKI_SIOCSIWTHRSPY:
4742 case VKI_SIOCSIWSCAN:
4743 case VKI_SIOCSIWESSID:
4744 case VKI_SIOCSIWRATE:
4745 case VKI_SIOCSIWNICKN:
4746 case VKI_SIOCSIWRTS:
4747 case VKI_SIOCSIWFRAG:
4748 case VKI_SIOCSIWTXPOW:
4749 case VKI_SIOCSIWRETRY:
4750 case VKI_SIOCSIWENCODE:
4751 case VKI_SIOCSIWPOWER:
4752 case VKI_SIOCSIWGENIE:
4753 case VKI_SIOCSIWMLME:
4754 case VKI_SIOCSIWAUTH:
4755 case VKI_SIOCSIWENCODEEXT:
4756 case VKI_SIOCSIWPMKSA:
4758 case VKI_SIOCGIWNAME:
4760 PRE_MEM_WRITE("ioctl(SIOCGIWNAME)",
4761 (Addr)((struct vki_iwreq *)ARG3)->u.name,
4762 sizeof(((struct vki_iwreq *)ARG3)->u.name));
4765 case VKI_SIOCGIWNWID:
4766 case VKI_SIOCGIWSENS:
4767 case VKI_SIOCGIWRATE:
4768 case VKI_SIOCGIWRTS:
4769 case VKI_SIOCGIWFRAG:
4770 case VKI_SIOCGIWTXPOW:
4771 case VKI_SIOCGIWRETRY:
4772 case VKI_SIOCGIWPOWER:
4773 case VKI_SIOCGIWAUTH:
4775 PRE_MEM_WRITE("ioctl(SIOCGIW[NWID|SENS|RATE|RTS|FRAG|TXPOW|"
4776 "RETRY|PARAM|AUTH])",
4777 (Addr)&((struct vki_iwreq *)ARG3)->u.nwid,
4778 sizeof(struct vki_iw_param));
4781 case VKI_SIOCGIWFREQ:
4783 PRE_MEM_WRITE("ioctl(SIOCGIWFREQ",
4784 (Addr)&((struct vki_iwreq *)ARG3)->u.freq,
4785 sizeof(struct vki_iw_freq));
4788 case VKI_SIOCGIWMODE:
4790 PRE_MEM_WRITE("ioctl(SIOCGIWMODE",
4791 (Addr)&((struct vki_iwreq *)ARG3)->u.mode,
4795 case VKI_SIOCGIWRANGE:
4796 case VKI_SIOCGIWPRIV:
4797 case VKI_SIOCGIWSTATS:
4798 case VKI_SIOCGIWSPY:
4799 case VKI_SIOCGIWTHRSPY:
4800 case VKI_SIOCGIWAPLIST:
4801 case VKI_SIOCGIWSCAN:
4802 case VKI_SIOCGIWESSID:
4803 case VKI_SIOCGIWNICKN:
4804 case VKI_SIOCGIWENCODE:
4805 case VKI_SIOCGIWGENIE:
4806 case VKI_SIOCGIWENCODEEXT:
4808 struct vki_iw_point* point;
4809 point = &((struct vki_iwreq *)ARG3)->u.data;
4810 PRE_MEM_WRITE("ioctl(SIOCGIW[RANGE|PRIV|STATS|SPY|THRSPY|"
4811 "APLIST|SCAN|ESSID|NICKN|ENCODE|GENIE|ENCODEEXT])",
4812 (Addr)point->pointer, point->length);
4817 PRE_MEM_WRITE("ioctl(SIOCGIWAP)",
4818 (Addr)&((struct vki_iwreq *)ARG3)->u.ap_addr,
4819 sizeof(struct vki_sockaddr));
4824 /* EVIOC* are variable length and return size written on success */
4825 switch (ARG2 & ~(_VKI_IOC_SIZEMASK << _VKI_IOC_SIZESHIFT)) {
4826 case VKI_EVIOCGNAME(0):
4827 case VKI_EVIOCGPHYS(0):
4828 case VKI_EVIOCGUNIQ(0):
4829 case VKI_EVIOCGKEY(0):
4830 case VKI_EVIOCGLED(0):
4831 case VKI_EVIOCGSND(0):
4832 case VKI_EVIOCGSW(0):
4833 case VKI_EVIOCGBIT(VKI_EV_SYN,0):
4834 case VKI_EVIOCGBIT(VKI_EV_KEY,0):
4835 case VKI_EVIOCGBIT(VKI_EV_REL,0):
4836 case VKI_EVIOCGBIT(VKI_EV_ABS,0):
4837 case VKI_EVIOCGBIT(VKI_EV_MSC,0):
4838 case VKI_EVIOCGBIT(VKI_EV_SW,0):
4839 case VKI_EVIOCGBIT(VKI_EV_LED,0):
4840 case VKI_EVIOCGBIT(VKI_EV_SND,0):
4841 case VKI_EVIOCGBIT(VKI_EV_REP,0):
4842 case VKI_EVIOCGBIT(VKI_EV_FF,0):
4843 case VKI_EVIOCGBIT(VKI_EV_PWR,0):
4844 case VKI_EVIOCGBIT(VKI_EV_FF_STATUS,0):
4846 PRE_MEM_WRITE("ioctl(EVIO*)", ARG3, _VKI_IOC_SIZE(ARG2));
4849 ML_(PRE_unknown_ioctl)(tid, ARG2, ARG3);
4859 switch (ARG2 /* request */) {
4865 POST_MEM_WRITE( ARG3, sizeof(struct vki_termios) );
4872 POST_MEM_WRITE( ARG3, sizeof(struct vki_termio) );
4879 case VKI_TIOCGWINSZ:
4880 POST_MEM_WRITE( ARG3, sizeof(struct vki_winsize) );
4882 case VKI_TIOCSWINSZ:
4888 POST_MEM_WRITE( ARG3, sizeof(unsigned int) );
4891 POST_MEM_WRITE( ARG3, sizeof(char *) );
4894 /* Get process group ID for foreground processing group. */
4895 POST_MEM_WRITE( ARG3, sizeof(vki_pid_t) );
4898 /* Set a process group ID? */
4899 POST_MEM_WRITE( ARG3, sizeof(vki_pid_t) );
4901 case VKI_TIOCGPTN: /* Get Pty Number (of pty-mux device) */
4902 POST_MEM_WRITE( ARG3, sizeof(int));
4906 case VKI_TIOCSPTLCK: /* Lock/unlock Pty */
4912 case VKI_FIONREAD: /* identical to SIOCINQ */
4913 POST_MEM_WRITE( ARG3, sizeof(int) );
4916 case VKI_TIOCSERGETLSR:
4917 POST_MEM_WRITE( ARG3, sizeof(int) );
4919 case VKI_TIOCGICOUNT:
4920 POST_MEM_WRITE( ARG3, sizeof(struct vki_serial_icounter_struct) );
4923 case VKI_SG_SET_COMMAND_Q:
4926 POST_MEM_WRITE(ARG3, sizeof(vki_sg_io_hdr_t));
4928 case VKI_SG_GET_SCSI_ID:
4929 POST_MEM_WRITE(ARG3, sizeof(vki_sg_scsi_id_t));
4931 case VKI_SG_SET_RESERVED_SIZE:
4933 case VKI_SG_SET_TIMEOUT:
4935 case VKI_SG_GET_RESERVED_SIZE:
4936 POST_MEM_WRITE(ARG3, sizeof(int));
4938 case VKI_SG_GET_TIMEOUT:
4940 case VKI_SG_GET_VERSION_NUM:
4941 POST_MEM_WRITE(ARG3, sizeof(int));
4943 case VKI_SG_EMULATED_HOST:
4944 POST_MEM_WRITE(ARG3, sizeof(int));
4946 case VKI_SG_GET_SG_TABLESIZE:
4947 POST_MEM_WRITE(ARG3, sizeof(int));
4950 case VKI_IIOCGETCPS:
4951 POST_MEM_WRITE( ARG3, VKI_ISDN_MAX_CHANNELS * 2 * sizeof(unsigned long) );
4953 case VKI_IIOCNETGPN:
4954 POST_MEM_WRITE( ARG3, sizeof(vki_isdn_net_ioctl_phone) );
4957 /* These all use struct ifreq AFAIK */
4958 case VKI_SIOCGIFINDEX: /* get iface index */
4959 POST_MEM_WRITE( (Addr)&((struct vki_ifreq *)ARG3)->vki_ifr_ifindex,
4960 sizeof(((struct vki_ifreq *)ARG3)->vki_ifr_ifindex) );
4962 case VKI_SIOCGIFFLAGS: /* get flags */
4963 POST_MEM_WRITE( (Addr)&((struct vki_ifreq *)ARG3)->vki_ifr_flags,
4964 sizeof(((struct vki_ifreq *)ARG3)->vki_ifr_flags) );
4966 case VKI_SIOCGIFHWADDR: /* Get hardware address */
4967 POST_MEM_WRITE( (Addr)&((struct vki_ifreq *)ARG3)->ifr_hwaddr,
4968 sizeof(((struct vki_ifreq *)ARG3)->ifr_hwaddr) );
4970 case VKI_SIOCGIFMTU: /* get MTU size */
4971 POST_MEM_WRITE( (Addr)&((struct vki_ifreq *)ARG3)->vki_ifr_mtu,
4972 sizeof(((struct vki_ifreq *)ARG3)->vki_ifr_mtu) );
4974 case VKI_SIOCGIFADDR: /* get PA address */
4975 case VKI_SIOCGIFDSTADDR: /* get remote PA address */
4976 case VKI_SIOCGIFBRDADDR: /* get broadcast PA address */
4977 case VKI_SIOCGIFNETMASK: /* get network PA mask */
4979 (Addr)&((struct vki_ifreq *)ARG3)->ifr_addr,
4980 sizeof(((struct vki_ifreq *)ARG3)->ifr_addr) );
4982 case VKI_SIOCGIFMETRIC: /* get metric */
4984 (Addr)&((struct vki_ifreq *)ARG3)->vki_ifr_metric,
4985 sizeof(((struct vki_ifreq *)ARG3)->vki_ifr_metric) );
4987 case VKI_SIOCGIFMAP: /* Get device parameters */
4989 (Addr)&((struct vki_ifreq *)ARG3)->ifr_map,
4990 sizeof(((struct vki_ifreq *)ARG3)->ifr_map) );
4993 case VKI_SIOCGIFTXQLEN: /* Get the tx queue length */
4995 (Addr)&((struct vki_ifreq *)ARG3)->ifr_qlen,
4996 sizeof(((struct vki_ifreq *)ARG3)->ifr_qlen) );
4998 case VKI_SIOCGIFNAME: /* get iface name */
5000 (Addr)&((struct vki_ifreq *)ARG3)->vki_ifr_name,
5001 sizeof(((struct vki_ifreq *)ARG3)->vki_ifr_name) );
5003 case VKI_SIOCGMIIPHY: /* get hardware entry */
5005 (Addr)&((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)ARG3)->vki_ifr_data)->phy_id,
5006 sizeof(((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)ARG3)->vki_ifr_data)->phy_id) );
5008 case VKI_SIOCGMIIREG: /* get hardware entry registers */
5010 (Addr)&((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)ARG3)->vki_ifr_data)->val_out,
5011 sizeof(((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)ARG3)->vki_ifr_data)->val_out) );
5013 case VKI_SIOCGIFCONF: /* get iface list */
5015 PRE_MEM_WRITE("ioctl(SIOCGIFCONF)", ARG3, sizeof(struct ifconf));
5016 KERNEL_DO_SYSCALL(tid,RES);
5017 if (!VG_(is_kerror)(RES) && RES == 0)
5018 POST_MEM_WRITE(ARG3, sizeof(struct ifconf));
5020 if (RES == 0 && ARG3 ) {
5021 struct vki_ifconf *ifc = (struct vki_ifconf *) ARG3;
5022 if (ifc->vki_ifc_buf != NULL)
5023 POST_MEM_WRITE( (Addr)(ifc->vki_ifc_buf), ifc->ifc_len );
5026 case VKI_SIOCGSTAMP:
5027 POST_MEM_WRITE( ARG3, sizeof(struct vki_timeval) );
5029 case VKI_SIOCGSTAMPNS:
5030 POST_MEM_WRITE( ARG3, sizeof(struct vki_timespec) );
5032 /* SIOCOUTQ is an ioctl that, when called on a socket, returns
5033 the number of bytes currently in that socket's send buffer.
5034 It writes this value as an int to the memory location
5035 indicated by the third argument of ioctl(2). */
5037 POST_MEM_WRITE(ARG3, sizeof(int));
5039 case VKI_SIOCGRARP: /* get RARP table entry */
5040 case VKI_SIOCGARP: /* get ARP table entry */
5041 POST_MEM_WRITE(ARG3, sizeof(struct vki_arpreq));
5044 case VKI_SIOCSIFFLAGS: /* set flags */
5045 case VKI_SIOCSIFMAP: /* Set device parameters */
5046 case VKI_SIOCSIFTXQLEN: /* Set the tx queue length */
5047 case VKI_SIOCSIFDSTADDR: /* set remote PA address */
5048 case VKI_SIOCSIFBRDADDR: /* set broadcast PA address */
5049 case VKI_SIOCSIFNETMASK: /* set network PA mask */
5050 case VKI_SIOCSIFMETRIC: /* set metric */
5051 case VKI_SIOCSIFADDR: /* set PA address */
5052 case VKI_SIOCSIFMTU: /* set MTU size */
5053 case VKI_SIOCSIFHWADDR: /* set hardware address */
5054 case VKI_SIOCSMIIREG: /* set hardware entry registers */
5056 /* Routing table calls. */
5057 case VKI_SIOCADDRT: /* add routing table entry */
5058 case VKI_SIOCDELRT: /* delete routing table entry */
5061 /* RARP cache control calls. */
5062 case VKI_SIOCDRARP: /* delete RARP table entry */
5063 case VKI_SIOCSRARP: /* set RARP table entry */
5064 /* ARP cache control calls. */
5065 case VKI_SIOCSARP: /* set ARP table entry */
5066 case VKI_SIOCDARP: /* delete ARP table entry */
5070 POST_MEM_WRITE(ARG3, sizeof(int));
5075 /* linux/soundcard interface (OSS) */
5076 case VKI_SNDCTL_SEQ_GETOUTCOUNT:
5077 case VKI_SNDCTL_SEQ_GETINCOUNT:
5078 case VKI_SNDCTL_SEQ_PERCMODE:
5079 case VKI_SNDCTL_SEQ_TESTMIDI:
5080 case VKI_SNDCTL_SEQ_RESETSAMPLES:
5081 case VKI_SNDCTL_SEQ_NRSYNTHS:
5082 case VKI_SNDCTL_SEQ_NRMIDIS:
5083 case VKI_SNDCTL_SEQ_GETTIME:
5084 case VKI_SNDCTL_DSP_GETBLKSIZE:
5085 case VKI_SNDCTL_DSP_GETFMTS:
5086 case VKI_SNDCTL_DSP_SETFMT:
5087 case VKI_SNDCTL_DSP_GETTRIGGER:
5088 case VKI_SNDCTL_DSP_GETODELAY:
5089 case VKI_SNDCTL_DSP_GETSPDIF:
5090 case VKI_SNDCTL_DSP_GETCAPS:
5091 case VKI_SOUND_PCM_READ_RATE:
5092 case VKI_SOUND_PCM_READ_CHANNELS:
5093 case VKI_SOUND_PCM_READ_BITS:
5094 case VKI_SOUND_PCM_READ_FILTER:
5095 POST_MEM_WRITE(ARG3, sizeof(int));
5097 case VKI_SNDCTL_SEQ_CTRLRATE:
5098 case VKI_SNDCTL_DSP_SPEED:
5099 case VKI_SNDCTL_DSP_STEREO:
5100 case VKI_SNDCTL_DSP_CHANNELS:
5101 case VKI_SOUND_PCM_WRITE_FILTER:
5102 case VKI_SNDCTL_DSP_SUBDIVIDE:
5103 case VKI_SNDCTL_DSP_SETFRAGMENT:
5104 case VKI_SNDCTL_DSP_GETCHANNELMASK:
5105 case VKI_SNDCTL_DSP_BIND_CHANNEL:
5106 case VKI_SNDCTL_TMR_TIMEBASE:
5107 case VKI_SNDCTL_TMR_TEMPO:
5108 case VKI_SNDCTL_TMR_SOURCE:
5109 case VKI_SNDCTL_MIDI_PRETIME:
5110 case VKI_SNDCTL_MIDI_MPUMODE:
5112 case VKI_SNDCTL_DSP_GETOSPACE:
5113 case VKI_SNDCTL_DSP_GETISPACE:
5114 POST_MEM_WRITE(ARG3, sizeof(vki_audio_buf_info));
5116 case VKI_SNDCTL_DSP_NONBLOCK:
5118 case VKI_SNDCTL_DSP_SETTRIGGER:
5121 case VKI_SNDCTL_DSP_POST:
5122 case VKI_SNDCTL_DSP_RESET:
5123 case VKI_SNDCTL_DSP_SYNC:
5124 case VKI_SNDCTL_DSP_SETSYNCRO:
5125 case VKI_SNDCTL_DSP_SETDUPLEX:
5128 /* linux/soundcard interface (ALSA) */
5129 case VKI_SNDRV_PCM_IOCTL_HW_FREE:
5130 case VKI_SNDRV_PCM_IOCTL_HWSYNC:
5131 case VKI_SNDRV_PCM_IOCTL_PREPARE:
5132 case VKI_SNDRV_PCM_IOCTL_RESET:
5133 case VKI_SNDRV_PCM_IOCTL_START:
5134 case VKI_SNDRV_PCM_IOCTL_DROP:
5135 case VKI_SNDRV_PCM_IOCTL_DRAIN:
5136 case VKI_SNDRV_PCM_IOCTL_RESUME:
5137 case VKI_SNDRV_PCM_IOCTL_XRUN:
5138 case VKI_SNDRV_PCM_IOCTL_UNLINK:
5139 case VKI_SNDRV_TIMER_IOCTL_START:
5140 case VKI_SNDRV_TIMER_IOCTL_STOP:
5141 case VKI_SNDRV_TIMER_IOCTL_CONTINUE:
5142 case VKI_SNDRV_TIMER_IOCTL_PAUSE:
5145 /* Real Time Clock (/dev/rtc) ioctls */
5146 case VKI_RTC_UIE_ON:
5147 case VKI_RTC_UIE_OFF:
5148 case VKI_RTC_AIE_ON:
5149 case VKI_RTC_AIE_OFF:
5150 case VKI_RTC_PIE_ON:
5151 case VKI_RTC_PIE_OFF:
5152 case VKI_RTC_IRQP_SET:
5154 case VKI_RTC_RD_TIME:
5155 case VKI_RTC_ALM_READ:
5156 POST_MEM_WRITE(ARG3, sizeof(struct vki_rtc_time));
5158 case VKI_RTC_ALM_SET:
5160 case VKI_RTC_IRQP_READ:
5161 POST_MEM_WRITE(ARG3, sizeof(unsigned long));
5168 POST_MEM_WRITE(ARG3, sizeof(int));
5170 case VKI_BLKGETSIZE:
5171 POST_MEM_WRITE(ARG3, sizeof(unsigned long));
5176 POST_MEM_WRITE(ARG3, sizeof(long));
5181 POST_MEM_WRITE(ARG3, sizeof(long));
5183 case VKI_BLKSECTGET:
5184 POST_MEM_WRITE(ARG3, sizeof(unsigned short));
5187 POST_MEM_WRITE(ARG3, sizeof(int));
5190 POST_MEM_WRITE(ARG3, sizeof(int));
5194 case VKI_BLKGETSIZE64:
5195 POST_MEM_WRITE(ARG3, sizeof(unsigned long long));
5199 case VKI_HDIO_GETGEO: /* 0x0301 */
5200 POST_MEM_WRITE(ARG3, sizeof(struct vki_hd_geometry));
5202 case VKI_HDIO_GET_DMA: /* 0x030b */
5203 POST_MEM_WRITE(ARG3, sizeof(long));
5205 case VKI_HDIO_GET_IDENTITY: /* 0x030d */
5206 POST_MEM_WRITE(ARG3, VKI_SIZEOF_STRUCT_HD_DRIVEID );
5209 /* CD ROM stuff (??) */
5210 case VKI_CDROMSUBCHNL:
5211 POST_MEM_WRITE(ARG3, sizeof(struct vki_cdrom_subchnl));
5213 case VKI_CDROMREADTOCHDR:
5214 POST_MEM_WRITE(ARG3, sizeof(struct vki_cdrom_tochdr));
5216 case VKI_CDROMREADTOCENTRY:
5217 POST_MEM_WRITE(ARG3, sizeof(struct vki_cdrom_tocentry));
5219 case VKI_CDROMMULTISESSION:
5220 POST_MEM_WRITE(ARG3, sizeof(struct vki_cdrom_multisession));
5222 case VKI_CDROMVOLREAD:
5223 POST_MEM_WRITE(ARG3, sizeof(struct vki_cdrom_volctrl));
5225 case VKI_CDROMREADRAW:
5226 POST_MEM_WRITE(ARG3, VKI_CD_FRAMESIZE_RAW);
5228 case VKI_CDROMREADAUDIO:
5230 struct vki_cdrom_read_audio *cra = (struct vki_cdrom_read_audio *) ARG3;
5231 POST_MEM_WRITE( (Addr)(cra->buf), cra->nframes * VKI_CD_FRAMESIZE_RAW);
5235 case VKI_CDROMPLAYMSF:
5237 /* The following two are probably bogus (should check args
5238 for readability). JRS 20021117 */
5239 case VKI_CDROM_DRIVE_STATUS: /* 0x5326 */
5240 case VKI_CDROM_CLEAR_OPTIONS: /* 0x5321 */
5244 POST_MEM_WRITE(ARG3, sizeof(unsigned long));
5247 POST_MEM_WRITE(ARG3, sizeof(unsigned long));
5250 case VKI_FBIOGET_VSCREENINFO: //0x4600
5251 POST_MEM_WRITE(ARG3, sizeof(struct vki_fb_var_screeninfo));
5253 case VKI_FBIOGET_FSCREENINFO: //0x4602
5254 POST_MEM_WRITE(ARG3, sizeof(struct vki_fb_fix_screeninfo));
5262 case VKI_PPSETPHASE:
5263 case VKI_PPSETFLAGS:
5265 case VKI_PPWCONTROL:
5266 case VKI_PPFCONTROL:
5269 case VKI_PPWCTLONIRQ:
5273 POST_MEM_WRITE( ARG3, sizeof(int) );
5275 case VKI_PPGETPHASE:
5276 POST_MEM_WRITE( ARG3, sizeof(int) );
5278 case VKI_PPGETMODES:
5279 POST_MEM_WRITE( ARG3, sizeof(unsigned int) );
5281 case VKI_PPGETFLAGS:
5282 POST_MEM_WRITE( ARG3, sizeof(int) );
5285 POST_MEM_WRITE( ARG3, sizeof(unsigned char) );
5288 POST_MEM_WRITE( ARG3, sizeof(unsigned char) );
5290 case VKI_PPRCONTROL:
5291 POST_MEM_WRITE( ARG3, sizeof(unsigned char) );
5294 POST_MEM_WRITE( ARG3, sizeof(int) );
5297 POST_MEM_WRITE( ARG3, sizeof(struct vki_timeval) );
5301 POST_MEM_WRITE( ARG3, 32 * 256 );
5307 POST_MEM_WRITE( (Addr)((struct vki_consolefontdesc *)ARG3)->chardata,
5308 32 * ((struct vki_consolefontdesc *)ARG3)->charcount );
5313 case VKI_PIO_FONTRESET:
5317 POST_MEM_WRITE( ARG3, 16 * 3 );
5327 POST_MEM_WRITE( ARG3, sizeof(char) );
5333 POST_MEM_WRITE( ARG3, sizeof(char) );
5345 POST_MEM_WRITE( ARG3, sizeof(int) );
5349 case VKI_KDUNMAPDISP:
5352 case VKI_GIO_SCRNMAP:
5353 POST_MEM_WRITE( ARG3, VKI_E_TABSZ );
5355 case VKI_PIO_SCRNMAP:
5357 case VKI_GIO_UNISCRNMAP:
5358 POST_MEM_WRITE( ARG3, VKI_E_TABSZ * sizeof(unsigned short) );
5360 case VKI_PIO_UNISCRNMAP:
5363 case VKI_GIO_UNIMAP:
5365 struct vki_unimapdesc *desc = (struct vki_unimapdesc *) ARG3;
5366 POST_MEM_WRITE( (Addr)&desc->entry_ct, sizeof(desc->entry_ct));
5367 POST_MEM_WRITE( (Addr)desc->entries,
5368 desc->entry_ct * sizeof(struct vki_unipair) );
5371 case VKI_PIO_UNIMAP:
5373 case VKI_PIO_UNIMAPCLR:
5377 POST_MEM_WRITE( ARG3, sizeof(int) );
5383 POST_MEM_WRITE( ARG3, sizeof(int) );
5389 POST_MEM_WRITE( ARG3, sizeof(char) );
5395 POST_MEM_WRITE( (Addr)&((struct vki_kbentry *)ARG3)->kb_value,
5396 sizeof(((struct vki_kbentry *)ARG3)->kb_value) );
5402 POST_MEM_WRITE( (Addr)((struct vki_kbsentry *)ARG3)->kb_string,
5403 sizeof(((struct vki_kbsentry *)ARG3)->kb_string) );
5408 case VKI_KDGKBDIACR:
5409 POST_MEM_WRITE( ARG3, sizeof(struct vki_kbdiacrs) );
5411 case VKI_KDSKBDIACR:
5414 case VKI_KDGETKEYCODE:
5415 POST_MEM_WRITE( (Addr)((struct vki_kbkeycode *)ARG3)->keycode,
5416 sizeof(((struct vki_kbkeycode *)ARG3)->keycode) );
5418 case VKI_KDSETKEYCODE:
5421 case VKI_KDSIGACCEPT:
5429 struct vki_console_font_op *op = (struct vki_console_font_op *) ARG3;
5431 case VKI_KD_FONT_OP_SET:
5433 case VKI_KD_FONT_OP_GET:
5435 POST_MEM_WRITE( (Addr) op->data,
5436 (op->width + 7) / 8 * 32 * op->charcount );
5438 case VKI_KD_FONT_OP_SET_DEFAULT:
5440 case VKI_KD_FONT_OP_COPY:
5443 POST_MEM_WRITE( (Addr) op, sizeof(*op));
5447 case VKI_VT_OPENQRY:
5448 POST_MEM_WRITE( ARG3, sizeof(int) );
5450 case VKI_VT_GETMODE:
5451 POST_MEM_WRITE( ARG3, sizeof(struct vki_vt_mode) );
5453 case VKI_VT_SETMODE:
5455 case VKI_VT_GETSTATE:
5456 POST_MEM_WRITE( (Addr) &(((struct vki_vt_stat*) ARG3)->v_active),
5457 sizeof(((struct vki_vt_stat*) ARG3)->v_active) );
5458 POST_MEM_WRITE( (Addr) &(((struct vki_vt_stat*) ARG3)->v_state),
5459 sizeof(((struct vki_vt_stat*) ARG3)->v_state) );
5461 case VKI_VT_RELDISP:
5462 case VKI_VT_ACTIVATE:
5463 case VKI_VT_WAITACTIVE:
5464 case VKI_VT_DISALLOCATE:
5468 case VKI_VT_RESIZEX:
5470 case VKI_VT_LOCKSWITCH:
5471 case VKI_VT_UNLOCKSWITCH:
5474 case VKI_USBDEVFS_CONTROL:
5476 struct vki_usbdevfs_ctrltransfer *vkuc = (struct vki_usbdevfs_ctrltransfer *)ARG3;
5477 if (vkuc->bRequestType & 0x80)
5478 POST_MEM_WRITE((Addr)vkuc->data, RES);
5481 case VKI_USBDEVFS_BULK:
5483 struct vki_usbdevfs_bulktransfer *vkub = (struct vki_usbdevfs_bulktransfer *)ARG3;
5484 if (vkub->ep & 0x80)
5485 POST_MEM_WRITE((Addr)vkub->data, RES);
5488 case VKI_USBDEVFS_GETDRIVER:
5490 struct vki_usbdevfs_getdriver *vkugd = (struct vki_usbdevfs_getdriver *)ARG3;
5491 POST_MEM_WRITE((Addr)&vkugd->driver, sizeof(vkugd->driver));
5494 case VKI_USBDEVFS_REAPURB:
5495 case VKI_USBDEVFS_REAPURBNDELAY:
5497 struct vki_usbdevfs_urb **vkuu = (struct vki_usbdevfs_urb**)ARG3;
5498 POST_MEM_WRITE((Addr)vkuu, sizeof(*vkuu));
5501 POST_MEM_WRITE((Addr) &((*vkuu)->status),sizeof((*vkuu)->status));
5502 if ((*vkuu)->type == VKI_USBDEVFS_URB_TYPE_CONTROL) {
5503 struct vki_usbdevfs_setuppacket *vkusp = (struct vki_usbdevfs_setuppacket *)(*vkuu)->buffer;
5504 if (vkusp->bRequestType & 0x80)
5505 POST_MEM_WRITE((Addr)(vkusp+1), (*vkuu)->buffer_length - sizeof(*vkusp));
5506 POST_MEM_WRITE((Addr)&(*vkuu)->actual_length, sizeof((*vkuu)->actual_length));
5507 } else if ((*vkuu)->type == VKI_USBDEVFS_URB_TYPE_ISO) {
5508 char *bp = (*vkuu)->buffer;
5510 for(i=0; i<(*vkuu)->number_of_packets; i++) {
5511 POST_MEM_WRITE((Addr)&(*vkuu)->iso_frame_desc[i].actual_length, sizeof((*vkuu)->iso_frame_desc[i].actual_length));
5512 POST_MEM_WRITE((Addr)&(*vkuu)->iso_frame_desc[i].status, sizeof((*vkuu)->iso_frame_desc[i].status));
5513 if ((*vkuu)->endpoint & 0x80)
5514 POST_MEM_WRITE((Addr)bp, (*vkuu)->iso_frame_desc[i].actual_length);
5515 bp += (*vkuu)->iso_frame_desc[i].length; // FIXME: or actual_length??
5517 POST_MEM_WRITE((Addr)&(*vkuu)->error_count, sizeof((*vkuu)->error_count));
5519 if ((*vkuu)->endpoint & 0x80)
5520 POST_MEM_WRITE((Addr)(*vkuu)->buffer, (*vkuu)->actual_length);
5521 POST_MEM_WRITE((Addr)&(*vkuu)->actual_length, sizeof((*vkuu)->actual_length));
5525 case VKI_USBDEVFS_CONNECTINFO:
5526 POST_MEM_WRITE(ARG3, sizeof(struct vki_usbdevfs_connectinfo));
5528 case VKI_USBDEVFS_IOCTL:
5530 struct vki_usbdevfs_ioctl *vkui = (struct vki_usbdevfs_ioctl *)ARG3;
5532 dir2 = _VKI_IOC_DIR(vkui->ioctl_code);
5533 size2 = _VKI_IOC_SIZE(vkui->ioctl_code);
5535 if (dir2 & _VKI_IOC_READ)
5536 POST_MEM_WRITE((Addr)vkui->data, size2);
5541 /* I2C (/dev/i2c-*) ioctls */
5543 case VKI_I2C_SLAVE_FORCE:
5544 case VKI_I2C_TENBIT:
5548 POST_MEM_WRITE( ARG3, sizeof(unsigned long) );
5551 /* Wireless extensions ioctls */
5552 case VKI_SIOCSIWCOMMIT:
5553 case VKI_SIOCSIWNWID:
5554 case VKI_SIOCSIWFREQ:
5555 case VKI_SIOCSIWMODE:
5556 case VKI_SIOCSIWSENS:
5557 case VKI_SIOCSIWRANGE:
5558 case VKI_SIOCSIWPRIV:
5559 case VKI_SIOCSIWSTATS:
5560 case VKI_SIOCSIWSPY:
5561 case VKI_SIOCSIWTHRSPY:
5563 case VKI_SIOCSIWSCAN:
5564 case VKI_SIOCSIWESSID:
5565 case VKI_SIOCSIWRATE:
5566 case VKI_SIOCSIWNICKN:
5567 case VKI_SIOCSIWRTS:
5568 case VKI_SIOCSIWFRAG:
5569 case VKI_SIOCSIWTXPOW:
5570 case VKI_SIOCSIWRETRY:
5571 case VKI_SIOCSIWENCODE:
5572 case VKI_SIOCSIWPOWER:
5573 case VKI_SIOCSIWGENIE:
5574 case VKI_SIOCSIWMLME:
5575 case VKI_SIOCSIWAUTH:
5576 case VKI_SIOCSIWENCODEEXT:
5577 case VKI_SIOCSIWPMKSA:
5579 case VKI_SIOCGIWNAME:
5581 POST_MEM_WRITE((Addr)((struct vki_iwreq *)ARG3)->u.name,
5582 sizeof(((struct vki_iwreq *)ARG3)->u.name));
5585 case VKI_SIOCGIWNWID:
5586 case VKI_SIOCGIWSENS:
5587 case VKI_SIOCGIWRATE:
5588 case VKI_SIOCGIWRTS:
5589 case VKI_SIOCGIWFRAG:
5590 case VKI_SIOCGIWTXPOW:
5591 case VKI_SIOCGIWRETRY:
5592 case VKI_SIOCGIWPOWER:
5593 case VKI_SIOCGIWAUTH:
5595 POST_MEM_WRITE((Addr)&((struct vki_iwreq *)ARG3)->u.param,
5596 sizeof(struct vki_iw_param));
5599 case VKI_SIOCGIWFREQ:
5601 POST_MEM_WRITE((Addr)&((struct vki_iwreq *)ARG3)->u.freq,
5602 sizeof(struct vki_iw_freq));
5605 case VKI_SIOCGIWMODE:
5607 POST_MEM_WRITE((Addr)&((struct vki_iwreq *)ARG3)->u.mode,
5611 case VKI_SIOCGIWRANGE:
5612 case VKI_SIOCGIWPRIV:
5613 case VKI_SIOCGIWSTATS:
5614 case VKI_SIOCGIWSPY:
5615 case VKI_SIOCGIWTHRSPY:
5616 case VKI_SIOCGIWAPLIST:
5617 case VKI_SIOCGIWSCAN:
5618 case VKI_SIOCGIWESSID:
5619 case VKI_SIOCGIWNICKN:
5620 case VKI_SIOCGIWENCODE:
5621 case VKI_SIOCGIWGENIE:
5622 case VKI_SIOCGIWENCODEEXT:
5624 struct vki_iw_point* point;
5625 point = &((struct vki_iwreq *)ARG3)->u.data;
5626 POST_MEM_WRITE((Addr)point->pointer, point->length);
5631 POST_MEM_WRITE((Addr)&((struct vki_iwreq *)ARG3)->u.ap_addr,
5632 sizeof(struct vki_sockaddr));
5637 /* EVIOC* are variable length and return size written on success */
5638 switch (ARG2 & ~(_VKI_IOC_SIZEMASK << _VKI_IOC_SIZESHIFT)) {
5639 case VKI_EVIOCGNAME(0):
5640 case VKI_EVIOCGPHYS(0):
5641 case VKI_EVIOCGUNIQ(0):
5642 case VKI_EVIOCGKEY(0):
5643 case VKI_EVIOCGLED(0):
5644 case VKI_EVIOCGSND(0):
5645 case VKI_EVIOCGSW(0):
5646 case VKI_EVIOCGBIT(VKI_EV_SYN,0):
5647 case VKI_EVIOCGBIT(VKI_EV_KEY,0):
5648 case VKI_EVIOCGBIT(VKI_EV_REL,0):
5649 case VKI_EVIOCGBIT(VKI_EV_ABS,0):
5650 case VKI_EVIOCGBIT(VKI_EV_MSC,0):
5651 case VKI_EVIOCGBIT(VKI_EV_SW,0):
5652 case VKI_EVIOCGBIT(VKI_EV_LED,0):
5653 case VKI_EVIOCGBIT(VKI_EV_SND,0):
5654 case VKI_EVIOCGBIT(VKI_EV_REP,0):
5655 case VKI_EVIOCGBIT(VKI_EV_FF,0):
5656 case VKI_EVIOCGBIT(VKI_EV_PWR,0):
5657 case VKI_EVIOCGBIT(VKI_EV_FF_STATUS,0):
5659 POST_MEM_WRITE(ARG3, RES);
5662 ML_(POST_unknown_ioctl)(tid, RES, ARG2, ARG3);
5669 /* ---------------------------------------------------------------------
5670 socketcall wrapper helpers
5671 ------------------------------------------------------------------ */
5674 ML_(linux_PRE_sys_getsockopt) ( ThreadId tid,
5675 UWord arg0, UWord arg1, UWord arg2,
5676 UWord arg3, UWord arg4 )
5678 /* int getsockopt(int s, int level, int optname,
5679 void *optval, socklen_t *optlen); */
5680 Addr optval_p = arg3;
5681 Addr optlen_p = arg4;
5682 /* vg_assert(sizeof(socklen_t) == sizeof(UInt)); */
5683 if (optval_p != (Addr)NULL) {
5684 ML_(buf_and_len_pre_check) ( tid, optval_p, optlen_p,
5685 "socketcall.getsockopt(optval)",
5686 "socketcall.getsockopt(optlen)" );
5687 if (arg1 == VKI_SOL_SCTP &&
5688 (arg2 == VKI_SCTP_GET_PEER_ADDRS ||
5689 arg2 == VKI_SCTP_GET_LOCAL_ADDRS))
5691 struct vki_sctp_getaddrs *ga = (struct vki_sctp_getaddrs*)arg3;
5692 int address_bytes = sizeof(struct vki_sockaddr_in6) * ga->addr_num;
5693 PRE_MEM_WRITE( "socketcall.getsockopt(optval.addrs)",
5694 (Addr)ga->addrs, address_bytes );
5700 ML_(linux_POST_sys_getsockopt) ( ThreadId tid,
5702 UWord arg0, UWord arg1, UWord arg2,
5703 UWord arg3, UWord arg4 )
5705 Addr optval_p = arg3;
5706 Addr optlen_p = arg4;
5707 vg_assert(!sr_isError(res)); /* guaranteed by caller */
5708 if (optval_p != (Addr)NULL) {
5709 ML_(buf_and_len_post_check) ( tid, res, optval_p, optlen_p,
5710 "socketcall.getsockopt(optlen_out)" );
5711 if (arg1 == VKI_SOL_SCTP &&
5712 (arg2 == VKI_SCTP_GET_PEER_ADDRS ||
5713 arg2 == VKI_SCTP_GET_LOCAL_ADDRS))
5715 struct vki_sctp_getaddrs *ga = (struct vki_sctp_getaddrs*)arg3;
5716 struct vki_sockaddr *a = ga->addrs;
5718 for (i = 0; i < ga->addr_num; i++) {
5720 if (a->sa_family == VKI_AF_INET)
5721 sl = sizeof(struct vki_sockaddr_in);
5722 else if (a->sa_family == VKI_AF_INET6)
5723 sl = sizeof(struct vki_sockaddr_in6);
5725 VG_(message)(Vg_UserMsg, "Warning: getsockopt: unhandled "
5726 "address type %d\n", a->sa_family);
5728 a = (struct vki_sockaddr*)((char*)a + sl);
5730 POST_MEM_WRITE( (Addr)ga->addrs, (char*)a - (char*)ga->addrs );
5738 #endif // defined(VGO_linux)
5740 /*--------------------------------------------------------------------*/
5742 /*--------------------------------------------------------------------*/