Some syscall improvements:
- made pre_mem_read etc. calls more concise by improving the macros used
- made printing calls more concise by renaming the macro used
- updated README_MISSING_SYSCALL_OR_IOCTL
- improved --trace-syscalls=yes; a bit neater, and now prints return values
for all syscalls.
- introduced LOHI64 macro for 64-bit args that are created from 2 32-bit args
- 64-bit cleanness tweaks for *xattr* syscall printing
git-svn-id: svn://svn.valgrind.org/valgrind/trunk@2941 a5019735-40e9-0310-863c-91ae7b9d1cf9
diff --git a/README_MISSING_SYSCALL_OR_IOCTL b/README_MISSING_SYSCALL_OR_IOCTL
index de88a83..231f693 100644
--- a/README_MISSING_SYSCALL_OR_IOCTL
+++ b/README_MISSING_SYSCALL_OR_IOCTL
@@ -49,16 +49,16 @@
PRE(time)
{
/* time_t time(time_t *t); */
- MAYBE_PRINTF("time ( %p )\n",arg1);
- if (arg1 != (UInt)NULL) {
- SYSCALL_TRACK( pre_mem_write, tid, "time", arg1, sizeof(time_t) );
+ PRINT("time ( %p )",arg1);
+ if (arg1 != (UWord)NULL) {
+ PRE_MEM_WRITE( "time", arg1, sizeof(time_t) );
}
}
POST(time)
{
- if (arg1 != (UInt)NULL) {
- VG_TRACK( post_mem_write, arg1, sizeof(time_t) );
+ if (arg1 != (UWord)NULL) {
+ POST_MEM_WRITE( arg1, sizeof(vki_time_t) );
}
}
@@ -66,8 +66,8 @@
if a non-NULL buffer is passed in as the argument, tell the tool that the
buffer is about to be written to:
- if (arg1 != (UInt)NULL) {
- SYSCALL_TRACK( pre_mem_write, tst, "time", arg1, sizeof(time_t) );
+ if (arg1 != (UWord)NULL) {
+ PRE_MEM_WRITE( "time", arg1, sizeof(vki_time_t) );
}
Finally, the really important bit, after the syscall occurs, in the POST()
@@ -75,7 +75,7 @@
the memory was written:
if (arg1 != (UInt)NULL) {
- VG_TRACK( post_mem_write, arg1, sizeof(time_t) );
+ POST_MEM_WRITE( arg1, sizeof(vki_time_t) );
}
The POST() function won't be called if the syscall failed, so you
@@ -85,6 +85,11 @@
time if interrupted. TODO: add another per-syscall flag for this
case.)
+Note that we use the type 'vki_time_t'. This is a copy of the kernel
+type, with 'vki_' prefixed. Our copies of such types are kept in the
+appropriate vki*.h file(s). We don't include kernel headers or glibc headers
+directly.
+
Writing your own syscall wrappers (see below for ioctl wrappers)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -98,6 +103,7 @@
This should tell you something like __NR_mysyscallname.
Copy this entry to coregrind/$(VG_PLATFORM)/vki_unistd.h.
+
2. Do 'man 2 mysyscallname' to get some idea of what the syscall
does. Note that the actual kernel interface can differ from this,
so you might also want to check a version of the Linux kernel
@@ -112,13 +118,13 @@
coregrind/vg_syscalls.c. For each in-memory parameter which is
read or written by the syscall, do one of
- SYSCALL_TRACK( pre_mem_read, ... )
- SYSCALL_TRACK( pre_mem_read_asciiz, ... )
- SYSCALL_TRACK( pre_mem_write, ... )
+ PRE_MEM_READ( ... )
+ PRE_MEM_RASCIIZ( ... )
+ PRE_MEM_WRITE( ... )
for that parameter. Then do the syscall. Then, if the syscall
- succeeds, issue suitable VG_TRACK( post_mem_write, ... ) calls.
- (There's no need for post_mem_read calls.)
+ succeeds, issue suitable POST_MEM_WRITE( ... ) calls.
+ (There's no need for POST_MEM_READ calls.)
Also, add it to the sys_info[] array; use SYSBA if it requires a
PRE() and POST() function, and SYSB_ if it only requires a PRE()
@@ -137,7 +143,7 @@
Test it.
- Note that a common error is to call VG_TRACK( post_mem_write, ... )
+ Note that a common error is to call POST_MEM_WRITE( ... )
with 0 (NULL) as the first (address) argument. This usually means
your logic is slightly inadequate. It's a sufficiently common bug
that there's a built-in check for it, and you'll get a "probably
diff --git a/coregrind/vg_proxylwp.c b/coregrind/vg_proxylwp.c
index 4945a87..8a97585 100644
--- a/coregrind/vg_proxylwp.c
+++ b/coregrind/vg_proxylwp.c
@@ -1014,15 +1014,16 @@
case PX_SetSigmask:
/* Don't need to do anything */
if (VG_(clo_trace_signals) || VG_(clo_trace_syscalls))
- VG_(message)(Vg_DebugMsg, "sys_wait_results: got PX_SetSigmask for TID %d",
+ VG_(printf)("sys_wait_results: got PX_SetSigmask for TID %d\n",
res.tid);
break;
case PX_RunSyscall:
if (VG_(clo_trace_syscalls))
- VG_(message)(Vg_DebugMsg, "sys_wait_results: got PX_RunSyscall for TID %d: syscall %d result %lld",
- res.tid, tst->syscallno,
- (ULong)PLATFORM_SYSCALL_RET(tst->arch));
+ VG_(printf)("sys_wait_results: got PX_RunSyscall for SYSCALL[%d,%d](%3d) --> %lld (%llx)\n",
+ VG_(getpid)(), res.tid, tst->syscallno,
+ (Long)(Word)PLATFORM_SYSCALL_RET(tst->arch),
+ (ULong)PLATFORM_SYSCALL_RET(tst->arch));
if (tst->status != VgTs_WaitSys)
VG_(printf)("tid %d in status %d\n",
@@ -1055,8 +1056,8 @@
}
if (VG_(clo_trace_signals) || VG_(clo_trace_syscalls))
- VG_(message)(Vg_DebugMsg, "sys_wait_results: got PX_Signal for TID %d, signal %d",
- res.tid, res.u.siginfo.si_signo);
+ VG_(printf)("sys_wait_results: got PX_Signal for TID %d, signal %d\n",
+ res.tid, res.u.siginfo.si_signo);
vg_assert(res.u.siginfo.si_signo != 0);
if (VG_(threads)[res.tid].proxy &&
diff --git a/coregrind/vg_syscalls.c b/coregrind/vg_syscalls.c
index b694fad..c8cf6f0 100644
--- a/coregrind/vg_syscalls.c
+++ b/coregrind/vg_syscalls.c
@@ -42,11 +42,17 @@
having the simulator retain control.
*/
-#define SYSCALL_TRACK(fn, args...) VG_TRACK(fn, Vg_CoreSysCall, ## args)
+#define PRE_MEM_READ(zzname, zzaddr, zzlen) \
+ VG_TRACK( pre_mem_read, Vg_CoreSysCall, tid, zzname, zzaddr, zzlen)
-#define MAYBE_PRINTF(format, args...) \
- if (VG_(clo_trace_syscalls)) \
- VG_(printf)(format, ## args)
+#define PRE_MEM_RASCIIZ(zzname, zzaddr) \
+ VG_TRACK( pre_mem_read_asciiz, Vg_CoreSysCall, tid, zzname, zzaddr)
+
+#define PRE_MEM_WRITE(zzname, zzaddr, zzlen) \
+ VG_TRACK( pre_mem_write, Vg_CoreSysCall, tid, zzname, zzaddr, zzlen)
+
+#define POST_MEM_WRITE(zzaddr, zzlen) \
+ VG_TRACK( post_mem_write, zzaddr, zzlen)
/* ---------------------------------------------------------------------
A simple atfork() facility for Valgrind's internal use
@@ -694,7 +700,7 @@
Char *msg, Addr base, SizeT size )
{
Char *outmsg = strdupcat ( "socketcall.sendmsg", msg, VG_AR_TRANSIENT );
- SYSCALL_TRACK( pre_mem_read, tid, outmsg, base, size );
+ PRE_MEM_READ( outmsg, base, size );
VG_(arena_free) ( VG_AR_TRANSIENT, outmsg );
}
@@ -704,7 +710,7 @@
Char *msg, Addr base, SizeT size )
{
Char *outmsg = strdupcat ( "socketcall.recvmsg", msg, VG_AR_TRANSIENT );
- SYSCALL_TRACK( pre_mem_write, tid, outmsg, base, size );
+ PRE_MEM_WRITE( outmsg, base, size );
VG_(arena_free) ( VG_AR_TRANSIENT, outmsg );
}
@@ -712,7 +718,7 @@
void post_mem_write_recvmsg ( ThreadId tid,
Char *fieldName, Addr base, SizeT size )
{
- VG_TRACK( post_mem_write, base, size );
+ POST_MEM_WRITE( base, size );
}
static
@@ -789,50 +795,49 @@
VG_(strlen)( description ) + 30 );
VG_(sprintf) ( outmsg, description, ".sa_family" );
- SYSCALL_TRACK( pre_mem_read, tid, outmsg,
- (Addr) &sa->sa_family, sizeof(vki_sa_family_t));
+ PRE_MEM_READ( outmsg, (Addr) &sa->sa_family, sizeof(vki_sa_family_t));
switch (sa->sa_family) {
case VKI_AF_UNIX:
VG_(sprintf) ( outmsg, description, ".sun_path" );
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, outmsg,
+ PRE_MEM_RASCIIZ( outmsg,
(Addr) ((struct vki_sockaddr_un *) sa)->sun_path);
break;
case VKI_AF_INET:
VG_(sprintf) ( outmsg, description, ".sin_port" );
- SYSCALL_TRACK( pre_mem_read, tid, outmsg,
+ PRE_MEM_READ( outmsg,
(Addr) &((struct vki_sockaddr_in *) sa)->sin_port,
sizeof (((struct vki_sockaddr_in *) sa)->sin_port));
VG_(sprintf) ( outmsg, description, ".sin_addr" );
- SYSCALL_TRACK( pre_mem_read, tid, outmsg,
+ PRE_MEM_READ( outmsg,
(Addr) &((struct vki_sockaddr_in *) sa)->sin_addr,
sizeof (struct vki_in_addr));
break;
case VKI_AF_INET6:
VG_(sprintf) ( outmsg, description, ".sin6_port" );
- SYSCALL_TRACK( pre_mem_read, tid, outmsg,
+ PRE_MEM_READ( outmsg,
(Addr) &((struct vki_sockaddr_in6 *) sa)->sin6_port,
sizeof (((struct vki_sockaddr_in6 *) sa)->sin6_port));
VG_(sprintf) ( outmsg, description, ".sin6_flowinfo" );
- SYSCALL_TRACK( pre_mem_read, tid, outmsg,
+ PRE_MEM_READ( outmsg,
(Addr) &((struct vki_sockaddr_in6 *) sa)->sin6_flowinfo,
sizeof (__vki_u32));
VG_(sprintf) ( outmsg, description, ".sin6_addr" );
- SYSCALL_TRACK( pre_mem_read, tid, outmsg,
+ PRE_MEM_READ( outmsg,
(Addr) &((struct vki_sockaddr_in6 *) sa)->sin6_addr,
sizeof (struct vki_in6_addr));
VG_(sprintf) ( outmsg, description, ".sin6_scope_id" );
- SYSCALL_TRACK( pre_mem_read, tid, outmsg,
+ PRE_MEM_READ( outmsg,
(Addr) &((struct vki_sockaddr_in6 *) sa)->sin6_scope_id,
sizeof (__vki_u32));
break;
default:
VG_(sprintf) ( outmsg, description, "" );
- SYSCALL_TRACK( pre_mem_read, tid, outmsg, (Addr) sa, salen );
+ PRE_MEM_READ( outmsg, (Addr) sa, salen );
break;
}
@@ -843,7 +848,7 @@
static UInt deref_UInt ( ThreadId tid, Addr a, Char* s )
{
UInt* a_p = (UInt*)a;
- SYSCALL_TRACK( pre_mem_read, tid, s, (Addr)a_p, sizeof(UInt) );
+ PRE_MEM_READ( s, (Addr)a_p, sizeof(UInt) );
if (a_p == NULL)
return 0;
else
@@ -854,7 +859,7 @@
static Addr deref_Addr ( ThreadId tid, Addr a, Char* s )
{
Addr* a_p = (Addr*)a;
- SYSCALL_TRACK( pre_mem_read, tid, s, (Addr)a_p, sizeof(Addr) );
+ PRE_MEM_READ( s, (Addr)a_p, sizeof(Addr) );
return *a_p;
}
@@ -992,10 +997,8 @@
#define MayBlock (1 << 0)
#define PostOnFail (1 << 1)
-#define PRE(x) \
- static void before_##x(ThreadId tid, ThreadState *tst)
-#define POST(x) \
- static void after_##x(ThreadId tid, ThreadState *tst)
+#define PRE(x) static void before_##x(ThreadId tid, ThreadState *tst)
+#define POST(x) static void after_##x(ThreadId tid, ThreadState *tst)
#define PREALIAS(new, old) \
PRE(new) __attribute__((alias(STR(before_##old))))
@@ -1013,6 +1016,13 @@
#define set_result(val) PLATFORM_SET_SYSCALL_RESULT(tst->arch, (val))
+#define PRINT(format, args...) \
+ if (VG_(clo_trace_syscalls)) \
+ VG_(printf)(format, ## args)
+
+// Combine two 32-bit values into a 64-bit value
+#define LOHI64(lo,hi) ( (lo) | ((ULong)(hi) << 32) )
+
PRE(exit_group)
{
VG_(core_panic)("syscall exit_group() not caught by the scheduler?!");
@@ -1027,34 +1037,34 @@
{
/* long ptrace (enum __ptrace_request request, pid_t pid,
void *addr, void *data); */
- MAYBE_PRINTF("ptrace ( %d, %d, %p, %p )\n", arg1,arg2,arg3,arg4);
+ PRINT("ptrace ( %d, %d, %p, %p )", arg1,arg2,arg3,arg4);
switch (arg1) {
case 12: /* PTRACE_GETREGS */
- SYSCALL_TRACK( pre_mem_write, tid, "ptrace(getregs)", arg4,
+ PRE_MEM_WRITE( "ptrace(getregs)", arg4,
sizeof (struct vki_user_regs_struct));
break;
case 14: /* PTRACE_GETFPREGS */
- SYSCALL_TRACK( pre_mem_write, tid, "ptrace(getfpregs)", arg4,
+ PRE_MEM_WRITE( "ptrace(getfpregs)", arg4,
sizeof (struct vki_user_i387_struct));
break;
case 18: /* PTRACE_GETFPXREGS */
- SYSCALL_TRACK( pre_mem_write, tid, "ptrace(getfpxregs)", arg4,
+ PRE_MEM_WRITE( "ptrace(getfpxregs)", arg4,
sizeof(struct vki_user_fxsr_struct) );
break;
case 1: case 2: case 3: /* PTRACE_PEEK{TEXT,DATA,USER} */
- SYSCALL_TRACK( pre_mem_write, tid, "ptrace(peek)", arg4,
+ PRE_MEM_WRITE( "ptrace(peek)", arg4,
sizeof (long));
break;
case 13: /* PTRACE_SETREGS */
- SYSCALL_TRACK( pre_mem_read, tid, "ptrace(setregs)", arg4,
+ PRE_MEM_READ( "ptrace(setregs)", arg4,
sizeof (struct vki_user_regs_struct));
break;
case 15: /* PTRACE_SETFPREGS */
- SYSCALL_TRACK( pre_mem_read, tid, "ptrace(setfpregs)", arg4,
+ PRE_MEM_READ( "ptrace(setfpregs)", arg4,
sizeof (struct vki_user_i387_struct));
break;
case 19: /* PTRACE_SETFPXREGS */
- SYSCALL_TRACK( pre_mem_read, tid, "ptrace(setfpxregs)", arg4,
+ PRE_MEM_READ( "ptrace(setfpxregs)", arg4,
sizeof(struct vki_user_fxsr_struct) );
break;
default:
@@ -1066,19 +1076,16 @@
{
switch (arg1) {
case 12: /* PTRACE_GETREGS */
- VG_TRACK( post_mem_write, arg4,
- sizeof (struct vki_user_regs_struct));
+ POST_MEM_WRITE( arg4, sizeof (struct vki_user_regs_struct));
break;
case 14: /* PTRACE_GETFPREGS */
- VG_TRACK( post_mem_write, arg4,
- sizeof (struct vki_user_i387_struct));
+ POST_MEM_WRITE( arg4, sizeof (struct vki_user_i387_struct));
break;
case 18: /* PTRACE_GETFPXREGS */
- VG_TRACK( post_mem_write, arg4,
- sizeof(struct vki_user_fxsr_struct) );
+ POST_MEM_WRITE( arg4, sizeof(struct vki_user_fxsr_struct) );
break;
case 1: case 2: case 3: /* PTRACE_PEEK{TEXT,DATA,USER} */
- VG_TRACK( post_mem_write, arg4, sizeof (long));
+ POST_MEM_WRITE( arg4, sizeof (long));
break;
default:
break;
@@ -1090,48 +1097,45 @@
// int mount(const char *source, const char *target,
// const char *filesystemtype, unsigned long mountflags,
// const void *data);
- MAYBE_PRINTF( "mount( %p, %p, %p, %p, %p )\n" ,arg1,arg2,arg3);
- SYSCALL_TRACK( pre_mem_read_asciiz, tid,"mount(specialfile)",arg1);
- SYSCALL_TRACK( pre_mem_read_asciiz, tid,"mount(dir)",arg2);
- SYSCALL_TRACK( pre_mem_read_asciiz, tid,"mount(filesystemtype)",arg3);
+ PRINT( "mount( %p, %p, %p, %p, %p )" ,arg1,arg2,arg3);
+ PRE_MEM_RASCIIZ( "mount(specialfile)", arg1);
+ PRE_MEM_RASCIIZ( "mount(dir)", arg2);
+ PRE_MEM_RASCIIZ( "mount(filesystemtype)", arg3);
}
PRE(umount)
{
/* int umount(const char *path) */
- MAYBE_PRINTF("umount( %p )\n", arg1);
- SYSCALL_TRACK( pre_mem_read_asciiz, tid,"umount(path)",arg1);
+ PRINT("umount( %p )", arg1);
+ PRE_MEM_RASCIIZ( "umount(path)",arg1);
}
PRE(modify_ldt)
{
- MAYBE_PRINTF("modify_ldt ( %d, %p, %d )\n", arg1,arg2,arg3);
+ PRINT("modify_ldt ( %d, %p, %d )", arg1,arg2,arg3);
if (arg1 == 0) {
/* read the LDT into ptr */
- SYSCALL_TRACK( pre_mem_write, tid,
- "modify_ldt(ptr)(func=0)", arg2, arg3 );
+ PRE_MEM_WRITE( "modify_ldt(ptr)(func=0)", arg2, arg3 );
}
if (arg1 == 1 || arg1 == 0x11) {
/* write the LDT with the entry pointed at by ptr */
- SYSCALL_TRACK( pre_mem_read, tid,
- "modify_ldt(ptr)(func=1 or 0x11)", arg2,
- sizeof(vki_modify_ldt_t) );
+ PRE_MEM_READ( "modify_ldt(ptr)(func=1 or 0x11)", arg2,
+ sizeof(vki_modify_ldt_t) );
}
/* "do" the syscall ourselves; the kernel never sees it */
res = VG_(sys_modify_ldt)( tid, arg1, (void*)arg2, arg3 );
if (arg1 == 0 && !VG_(is_kerror)(res) && res > 0) {
- VG_TRACK( post_mem_write, arg2, res );
+ POST_MEM_WRITE( arg2, res );
}
}
PRE(set_thread_area)
{
- MAYBE_PRINTF("set_thread_area ( %p )\n", arg1);
+ PRINT("set_thread_area ( %p )", arg1);
- SYSCALL_TRACK( pre_mem_read, tid,
- "set_thread_area(ptr)", arg1,
- sizeof(vki_modify_ldt_t) );
+ PRE_MEM_READ( "set_thread_area(ptr)", arg1,
+ sizeof(vki_modify_ldt_t) );
/* "do" the syscall ourselves; the kernel never sees it */
set_result( VG_(sys_set_thread_area)( tid, (void *)arg1 ) );
@@ -1139,47 +1143,46 @@
PRE(get_thread_area)
{
- MAYBE_PRINTF("get_thread_area ( %p )\n", arg1);
- SYSCALL_TRACK( pre_mem_write, tid,
- "get_thread_area(ptr)", arg1,
+ PRINT("get_thread_area ( %p )", arg1);
+ PRE_MEM_WRITE( "get_thread_area(ptr)", arg1,
sizeof(vki_modify_ldt_t) );
/* "do" the syscall ourselves; the kernel never sees it */
set_result( VG_(sys_get_thread_area)( tid, (void *)arg1 ) );
if (!VG_(is_kerror)(res)) {
- VG_TRACK( post_mem_write, arg1, sizeof(vki_modify_ldt_t) );
+ POST_MEM_WRITE( arg1, sizeof(vki_modify_ldt_t) );
}
}
PRE(set_tid_address)
{
- MAYBE_PRINTF("set_tid_address ( %p )\n", arg1);
+ PRINT("set_tid_address ( %p )", arg1);
}
PRE(setresgid)
{
/* int setresgid(gid_t rgid, gid_t egid, gid_t sgid); */
- MAYBE_PRINTF("setresgid ( %d, %d, %d )\n", arg1, arg2, arg3);
+ PRINT("setresgid ( %d, %d, %d )", arg1, arg2, arg3);
}
PRE(vhangup)
{
- MAYBE_PRINTF("vhangup()\n");
+ PRINT("vhangup()");
}
PRE(iopl)
{
- MAYBE_PRINTF("iopl ( %d )\n", arg1);
+ PRINT("iopl ( %d )", arg1);
}
PRE(setxattr)
{
- MAYBE_PRINTF("setxattr ( %p, %p, %p, %d, %d )\n",
- arg1, arg2, arg3, arg4, arg5);
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "setxattr(path)", arg1 );
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "setxattr(name)", arg2 );
- SYSCALL_TRACK( pre_mem_read, tid, "setxattr(value)", arg3, arg4 );
+ PRINT("setxattr ( %p, %p, %p, %llu, %d )",
+ arg1, arg2, arg3, (ULong)arg4, arg5);
+ PRE_MEM_RASCIIZ( "setxattr(path)", arg1 );
+ PRE_MEM_RASCIIZ( "setxattr(name)", arg2 );
+ PRE_MEM_READ( "setxattr(value)", arg3, arg4 );
}
PREALIAS(lsetxattr, setxattr);
@@ -1188,25 +1191,24 @@
{
/* int fsetxattr (int filedes, const char *name,
const void *value, size_t size, int flags); */
- MAYBE_PRINTF("fsetxattr ( %d, %p, %p, %llu, %d )\n",
- arg1, arg2, arg3, (ULong)arg4, arg5);
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "fsetxattr(name)", arg2 );
- SYSCALL_TRACK( pre_mem_read, tid, "fsetxattr(value)", arg3, arg4 );
+ PRINT("fsetxattr ( %d, %p, %p, %llu, %d )",
+ arg1, arg2, arg3, (ULong)arg4, arg5);
+ PRE_MEM_RASCIIZ( "fsetxattr(name)", arg2 );
+ PRE_MEM_READ( "fsetxattr(value)", arg3, arg4 );
}
PRE(getxattr)
{
- MAYBE_PRINTF("getxattr ( %p, %p, %p, %d )\n",
- arg1,arg2,arg3, arg4);
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "getxattr(path)", arg1 );
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "getxattr(name)", arg2 );
- SYSCALL_TRACK( pre_mem_write, tid, "getxattr(value)", arg3, arg4 );
+ PRINT("getxattr ( %p, %p, %p, %llu )", arg1,arg2,arg3, (ULong)arg4);
+ PRE_MEM_RASCIIZ( "getxattr(path)", arg1 );
+ PRE_MEM_RASCIIZ( "getxattr(name)", arg2 );
+ PRE_MEM_WRITE( "getxattr(value)", arg3, arg4 );
}
POST(getxattr)
{
if (res > 0 && arg3 != (Addr)NULL) {
- VG_TRACK( post_mem_write, arg3, res );
+ POST_MEM_WRITE( arg3, res );
}
}
@@ -1215,29 +1217,28 @@
PRE(fgetxattr)
{
- MAYBE_PRINTF("fgetxattr ( %d, %p, %p, %d )\n",
- arg1, arg2, arg3, arg4);
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "fgetxattr(name)", arg2 );
- SYSCALL_TRACK( pre_mem_write, tid, "fgetxattr(value)", arg3, arg4 );
+ PRINT("fgetxattr ( %d, %p, %p, %llu )", arg1, arg2, arg3, (ULong)arg4);
+ PRE_MEM_RASCIIZ( "fgetxattr(name)", arg2 );
+ PRE_MEM_WRITE( "fgetxattr(value)", arg3, arg4 );
}
POST(fgetxattr)
{
if (res > 0 && arg3 != (Addr)NULL)
- VG_TRACK( post_mem_write, arg3, res );
+ POST_MEM_WRITE( arg3, res );
}
PRE(listxattr)
{
- MAYBE_PRINTF("listxattr ( %p, %p, %d )\n", arg1, arg2, arg3);
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "listxattr(path)", arg1 );
- SYSCALL_TRACK( pre_mem_write, tid, "listxattr(list)", arg2, arg3 );
+ PRINT("listxattr ( %p, %p, %llu )", arg1, arg2, (ULong)arg3);
+ PRE_MEM_RASCIIZ( "listxattr(path)", arg1 );
+ PRE_MEM_WRITE( "listxattr(list)", arg2, arg3 );
}
POST(listxattr)
{
if (res > 0 && arg2 != (Addr)NULL)
- VG_TRACK( post_mem_write, arg2, res );
+ POST_MEM_WRITE( arg2, res );
}
PREALIAS(llistxattr, listxattr);
@@ -1246,71 +1247,72 @@
PRE(flistxattr)
{
/* ssize_t flistxattr (int filedes, char *list, size_t size); */
- MAYBE_PRINTF("flistxattr ( %d, %p, %llu )\n", arg1, arg2, (ULong)arg3);
- SYSCALL_TRACK( pre_mem_write, tid, "listxattr(list)", arg2, arg3 );
+ PRINT("flistxattr ( %d, %p, %llu )", arg1, arg2, (ULong)arg3);
+ PRE_MEM_WRITE( "listxattr(list)", arg2, arg3 );
}
POST(flistxattr)
{
if (res > 0 && arg2 != (Addr)NULL)
- VG_TRACK( post_mem_write, arg2, res );
+ POST_MEM_WRITE( arg2, res );
}
PRE(removexattr)
{
- MAYBE_PRINTF("removexattr ( %p, %p )\n", arg1, arg2);
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "listxattr(path)", arg1 );
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "listxattr(name)", arg2 );
+ PRINT("removexattr ( %p, %p )", arg1, arg2);
+ PRE_MEM_RASCIIZ( "listxattr(path)", arg1 );
+ PRE_MEM_RASCIIZ( "listxattr(name)", arg2 );
}
PREALIAS(lremovexattr, removexattr);
PRE(fremovexattr)
{
- MAYBE_PRINTF("removexattr ( %d, %p )\n", arg1, arg2);
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "listxattr(name)", arg2 );
+ PRINT("removexattr ( %d, %p )", arg1, arg2);
+ PRE_MEM_RASCIIZ( "listxattr(name)", arg2 );
}
PRE(quotactl)
{
- MAYBE_PRINTF("quotactl (0x%x, %p, 0x%x, 0x%x )\n",
- arg1,arg2,arg3, arg4);
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "quotactl(special)", arg2 );
+ PRINT("quotactl (0x%x, %p, 0x%x, 0x%x )", arg1,arg2,arg3, arg4);
+ PRE_MEM_RASCIIZ( "quotactl(special)", arg2 );
}
PRE(lookup_dcookie)
{
- MAYBE_PRINTF("lookup_dcookie (0x%llx, %p, %d)\n",
- arg1 | ((long long) arg2 << 32), arg3, arg4);
- SYSCALL_TRACK( pre_mem_write, tid, "lookup_dcookie(buf)", arg3, arg4);
+ PRINT("lookup_dcookie (0x%llx, %p, %d)", LOHI64(arg1,arg2), arg3, arg4);
+ PRE_MEM_WRITE( "lookup_dcookie(buf)", arg3, arg4);
}
POST(lookup_dcookie)
{
if (arg3 != (Addr)NULL)
- VG_TRACK( post_mem_write, arg3, res);
+ POST_MEM_WRITE( arg3, res);
}
PRE(truncate64)
{
- MAYBE_PRINTF("truncate64 ( %p, %lld )\n",
- arg1, ((ULong)arg2) | (((ULong) arg3) << 32));
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "truncate64(path)", arg1 );
+ PRINT("truncate64 ( %p, %lld )", arg1, LOHI64(arg2, arg3));
+ PRE_MEM_RASCIIZ( "truncate64(path)", arg1 );
}
PRE(fdatasync)
{
/* int fdatasync(int fd); */
- MAYBE_PRINTF("fdatasync ( %d )\n", arg1);
+ PRINT("fdatasync ( %d )", arg1);
}
PRE(msync)
{
/* int msync(const void *start, size_t length, int flags); */
- MAYBE_PRINTF("msync ( %p, %llu, %d )\n", arg1,(ULong)arg2,arg3);
- SYSCALL_TRACK( pre_mem_read, tid, "msync(start)", arg1, arg2 );
+ PRINT("msync ( %p, %llu, %d )", arg1,(ULong)arg2,arg3);
+ PRE_MEM_READ( "msync(start)", arg1, arg2 );
}
+// Nb: getpmsg() and putpmsg() are special additional syscalls used in early
+// versions of LiS (Linux Streams). They are not part of the kernel.
+// Therefore, we have to provide this type ourself, rather than getting it
+// from the kernel sources.
struct pmsg_strbuf {
int maxlen; /* no. of bytes in buffer */
int len; /* no. of bytes returned */
@@ -1324,22 +1326,17 @@
int *bandp, int *flagsp); */
struct pmsg_strbuf *ctrl;
struct pmsg_strbuf *data;
- MAYBE_PRINTF("getpmsg ( %d, %p, %p, %p, %p )\n",
- arg1,arg2,arg3,arg4,arg5);
+ PRINT("getpmsg ( %d, %p, %p, %p, %p )", arg1,arg2,arg3,arg4,arg5);
ctrl = (struct pmsg_strbuf *)arg2;
data = (struct pmsg_strbuf *)arg3;
if (ctrl && ctrl->maxlen > 0)
- SYSCALL_TRACK( pre_mem_write,tid, "getpmsg(ctrl)",
- (Addr)ctrl->buf, ctrl->maxlen);
+ PRE_MEM_WRITE( "getpmsg(ctrl)", (Addr)ctrl->buf, ctrl->maxlen);
if (data && data->maxlen > 0)
- SYSCALL_TRACK( pre_mem_write,tid, "getpmsg(data)",
- (Addr)data->buf, data->maxlen);
+ PRE_MEM_WRITE( "getpmsg(data)", (Addr)data->buf, data->maxlen);
if (arg4)
- SYSCALL_TRACK( pre_mem_write,tid, "getpmsg(bandp)",
- (Addr)arg4, sizeof(int));
+ PRE_MEM_WRITE( "getpmsg(bandp)", (Addr)arg4, sizeof(int));
if (arg5)
- SYSCALL_TRACK( pre_mem_write,tid, "getpmsg(flagsp)",
- (Addr)arg5, sizeof(int));
+ PRE_MEM_WRITE( "getpmsg(flagsp)", (Addr)arg5, sizeof(int));
}
POST(getpmsg)
@@ -1350,10 +1347,10 @@
ctrl = (struct pmsg_strbuf *)arg2;
data = (struct pmsg_strbuf *)arg3;
if (res == 0 && ctrl && ctrl->len > 0) {
- VG_TRACK( post_mem_write, (Addr)ctrl->buf, ctrl->len);
+ POST_MEM_WRITE( (Addr)ctrl->buf, ctrl->len);
}
if (res == 0 && data && data->len > 0) {
- VG_TRACK( post_mem_write, (Addr)data->buf, data->len);
+ POST_MEM_WRITE( (Addr)data->buf, data->len);
}
}
@@ -1364,24 +1361,20 @@
int band, int flags); */
struct pmsg_strbuf *ctrl;
struct pmsg_strbuf *data;
- MAYBE_PRINTF("putpmsg ( %d, %p, %p, %d, %d )\n",
- arg1,arg2,arg3,arg4,arg5);
+ PRINT("putpmsg ( %d, %p, %p, %d, %d )", arg1,arg2,arg3,arg4,arg5);
ctrl = (struct pmsg_strbuf *)arg2;
data = (struct pmsg_strbuf *)arg3;
if (ctrl && ctrl->len > 0)
- SYSCALL_TRACK( pre_mem_read,tid, "putpmsg(ctrl)",
- (Addr)ctrl->buf, ctrl->len);
+ PRE_MEM_READ( "putpmsg(ctrl)", (Addr)ctrl->buf, ctrl->len);
if (data && data->len > 0)
- SYSCALL_TRACK( pre_mem_read,tid, "putpmsg(data)",
- (Addr)data->buf, data->len);
+ PRE_MEM_READ( "putpmsg(data)", (Addr)data->buf, data->len);
}
PRE(getitimer)
{
/* int getitimer(int which, struct itimerval *value); */
- MAYBE_PRINTF("getitimer ( %d, %p )\n", arg1, arg2);
- SYSCALL_TRACK( pre_mem_write, tid, "getitimer(timer)", arg2,
- sizeof(struct vki_itimerval) );
+ PRINT("getitimer ( %d, %p )", arg1, arg2);
+ PRE_MEM_WRITE( "getitimer(timer)", arg2, sizeof(struct vki_itimerval) );
}
POST(getitimer)
@@ -1394,10 +1387,10 @@
PRE(syslog)
{
/* int syslog(int type, char *bufp, int len); */
- MAYBE_PRINTF("syslog (%d, %p, %d)\n",arg1,arg2,arg3);
+ PRINT("syslog (%d, %p, %d)",arg1,arg2,arg3);
switch(arg1) {
case 2: case 3: case 4:
- SYSCALL_TRACK( pre_mem_write, tid, "syslog(buf)", arg2, arg3);
+ PRE_MEM_WRITE( "syslog(buf)", arg2, arg3);
break;
default:
break;
@@ -1408,7 +1401,7 @@
{
switch (arg1) {
case 2: case 3: case 4:
- VG_TRACK( post_mem_write, arg2, arg3 );
+ POST_MEM_WRITE( arg2, arg3 );
break;
default:
break;
@@ -1418,20 +1411,20 @@
PRE(personality)
{
/* int personality(unsigned long persona); */
- MAYBE_PRINTF("personality ( %d )\n", arg1);
+ PRINT("personality ( %d )", arg1);
}
PRE(chroot)
{
/* int chroot(const char *path); */
- MAYBE_PRINTF("chroot ( %p )\n", arg1);
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "chroot(path)", arg1 );
+ PRINT("chroot ( %p )", arg1);
+ PRE_MEM_RASCIIZ( "chroot(path)", arg1 );
}
PRE(madvise)
{
/* int madvise(void *start, size_t length, int advice ); */
- MAYBE_PRINTF("madvise ( %p, %llu, %d )\n", arg1,(ULong)arg2,arg3);
+ PRINT("madvise ( %p, %llu, %d )", arg1,(ULong)arg2,arg3);
}
PRE(mremap)
@@ -1440,7 +1433,7 @@
// which lacks the fifth 'new_address' argument.
/* void* mremap(void * old_address, size_t old_size,
size_t new_size, unsigned long flags, void * new_address); */
- MAYBE_PRINTF("mremap ( %p, %llu, %d, 0x%x, %p )\n",
+ PRINT("mremap ( %p, %llu, %d, 0x%x, %p )",
arg1, (ULong)arg2, arg3, arg4, arg5);
set_result( mremap_segment((Addr)arg1, arg2, (Addr)arg5, arg3, arg4, tid) );
@@ -1449,268 +1442,259 @@
PRE(nice)
{
/* int nice(int inc); */
- MAYBE_PRINTF("nice ( %d )\n", arg1);
+ PRINT("nice ( %d )", arg1);
}
PRE(setresgid32)
{
/* int setresgid(gid_t rgid, gid_t egid, gid_t sgid); */
- MAYBE_PRINTF("setresgid32 ( %d, %d, %d )\n", arg1, arg2, arg3);
+ PRINT("setresgid32 ( %d, %d, %d )", arg1, arg2, arg3);
}
PRE(setfsuid32)
{
/* int setfsuid(uid_t fsuid); */
- MAYBE_PRINTF("setfsuid ( %d )\n", arg1);
+ PRINT("setfsuid ( %d )", arg1);
}
PRE(_sysctl)
{
/* int _sysctl(struct __sysctl_args *args); */
- MAYBE_PRINTF("_sysctl ( %p )\n", arg1 );
- SYSCALL_TRACK( pre_mem_write, tid, "_sysctl(args)", arg1,
- sizeof(struct __vki_sysctl_args) );
+ PRINT("_sysctl ( %p )", arg1 );
+ PRE_MEM_WRITE( "_sysctl(args)", arg1, sizeof(struct __vki_sysctl_args) );
}
POST(_sysctl)
{
- VG_TRACK( post_mem_write, arg1, sizeof(struct __vki_sysctl_args) );
+ POST_MEM_WRITE( arg1, sizeof(struct __vki_sysctl_args) );
}
PRE(sched_getscheduler)
{
/* int sched_getscheduler(pid_t pid); */
- MAYBE_PRINTF("sched_getscheduler ( %d )\n", arg1);
+ PRINT("sched_getscheduler ( %d )", arg1);
}
PRE(sched_setscheduler)
{
/* int sched_setscheduler(pid_t pid, int policy,
const struct sched_param *p); */
- MAYBE_PRINTF("sched_setscheduler ( %d, %d, %p )\n",arg1,arg2,arg3);
+ PRINT("sched_setscheduler ( %d, %d, %p )",arg1,arg2,arg3);
if (arg3 != (UWord)NULL)
- SYSCALL_TRACK( pre_mem_read, tid,
- "sched_setscheduler(struct sched_param *p)",
- arg3, sizeof(struct vki_sched_param));
+ PRE_MEM_READ( "sched_setscheduler(struct sched_param *p)",
+ arg3, sizeof(struct vki_sched_param));
}
PRE(mlock)
{
/* int mlock(const void * addr, size_t len) */
- MAYBE_PRINTF("mlock ( %p, %llu )\n", arg1, (ULong)arg2);
+ PRINT("mlock ( %p, %llu )", arg1, (ULong)arg2);
}
PRE(munlock)
{
/* int munlock(const void * addr, size_t len) */
- MAYBE_PRINTF("munlock ( %p, %llu )\n", arg1, (ULong)arg2);
+ PRINT("munlock ( %p, %llu )", arg1, (ULong)arg2);
}
PRE(mlockall)
{
/* int mlockall(int flags); */
- MAYBE_PRINTF("mlockall ( %x )\n", arg1);
+ PRINT("mlockall ( %x )", arg1);
}
PRE(munlockall)
{
/* int munlockall(void) */
- MAYBE_PRINTF("munlockall()\n");
+ PRINT("munlockall()");
}
PRE(sched_get_priority_max)
{
/* int sched_get_priority_max(int policy); */
- MAYBE_PRINTF("sched_get_priority_max ( %d )\n", arg1);
+ PRINT("sched_get_priority_max ( %d )", arg1);
}
PRE(sched_get_priority_min)
{
/* int sched_get_priority_min(int policy); */
- MAYBE_PRINTF("sched_get_priority_min ( %d )\n", arg1);
+ PRINT("sched_get_priority_min ( %d )", arg1);
}
PRE(setpriority)
{
/* int setpriority(int which, int who, int prio); */
- MAYBE_PRINTF("setpriority ( %d, %d, %d )\n", arg1, arg2, arg3);
+ PRINT("setpriority ( %d, %d, %d )", arg1, arg2, arg3);
}
PRE(getpriority)
{
/* int getpriority(int which, int who); */
- MAYBE_PRINTF("getpriority ( %d, %d )\n", arg1, arg2);
+ PRINT("getpriority ( %d, %d )", arg1, arg2);
}
PRE(setfsgid)
{
/* int setfsgid(gid_t gid); */
- MAYBE_PRINTF("setfsgid ( %d )\n", arg1);
+ PRINT("setfsgid ( %d )", arg1);
}
PRE(setregid)
{
/* int setregid(gid_t rgid, gid_t egid); */
- MAYBE_PRINTF("setregid ( %d, %d )\n", arg1, arg2);
+ PRINT("setregid ( %d, %d )", arg1, arg2);
}
PRE(setresuid)
{
/* int setresuid(uid_t ruid, uid_t euid, uid_t suid); */
- MAYBE_PRINTF("setresuid ( %d, %d, %d )\n", arg1, arg2, arg3);
+ PRINT("setresuid ( %d, %d, %d )", arg1, arg2, arg3);
}
PRE(setfsuid)
{
/* int setfsuid(uid_t uid); */
- MAYBE_PRINTF("setfsuid ( %d )\n", arg1);
+ PRINT("setfsuid ( %d )", arg1);
}
PRE(sendfile)
{
/* ssize_t sendfile(int out_fd, int in_fd, off_t *offset,
size_t count) */
- MAYBE_PRINTF("sendfile ( %d, %d, %p, %llu )\n",arg1,arg2,arg3,(ULong)arg4);
+ PRINT("sendfile ( %d, %d, %p, %llu )",arg1,arg2,arg3,(ULong)arg4);
if (arg3 != (UWord)NULL)
- SYSCALL_TRACK( pre_mem_write, tid, "sendfile(offset)",
- arg3, sizeof(vki_off_t) );
+ PRE_MEM_WRITE( "sendfile(offset)", arg3, sizeof(vki_off_t) );
}
POST(sendfile)
{
- VG_TRACK( post_mem_write, arg3, sizeof( vki_off_t ) );
+ POST_MEM_WRITE( arg3, sizeof( vki_off_t ) );
}
PRE(sendfile64)
{
/* ssize_t sendfile64(int out_df, int in_fd, loff_t *offset,
size_t count); */
- MAYBE_PRINTF("sendfile64 ( %d, %d, %p, %llu )\n",arg1,arg2,arg3,(ULong)arg4);
+ PRINT("sendfile64 ( %d, %d, %p, %llu )",arg1,arg2,arg3,(ULong)arg4);
if (arg3 != (UWord)NULL)
- SYSCALL_TRACK( pre_mem_write, tid, "sendfile64(offset)",
- arg3, sizeof(vki_loff_t) );
+ PRE_MEM_WRITE( "sendfile64(offset)", arg3, sizeof(vki_loff_t) );
}
POST(sendfile64)
{
if (arg3 != (UWord)NULL ) {
- VG_TRACK( post_mem_write, arg3, sizeof(vki_loff_t) );
+ POST_MEM_WRITE( arg3, sizeof(vki_loff_t) );
}
}
PRE(pwrite64)
{
// ssize_t pwrite64(int fd, const void *buf, size_t nbytes, loff_t offset);
- MAYBE_PRINTF("pwrite64 ( %d, %p, %llu, %lld )\n",
- arg1, arg2, (ULong)arg3, arg4|((ULong) arg5 << 32));
- SYSCALL_TRACK( pre_mem_read, tid, "pwrite64(buf)", arg2, arg3 );
+ PRINT("pwrite64 ( %d, %p, %llu, %lld )",
+ arg1, arg2, (ULong)arg3, LOHI64(arg4,arg5));
+ PRE_MEM_READ( "pwrite64(buf)", arg2, arg3 );
}
PRE(sync)
{
/* int sync(); */
- MAYBE_PRINTF("sync ( )\n");
+ PRINT("sync ( )");
}
PRE(fstatfs)
{
/* int fstatfs(int fd, struct statfs *buf); */
- MAYBE_PRINTF("fstatfs ( %d, %p )\n",arg1,arg2);
- SYSCALL_TRACK( pre_mem_write, tid, "stat(buf)",
- arg2, sizeof(struct vki_statfs) );
+ PRINT("fstatfs ( %d, %p )",arg1,arg2);
+ PRE_MEM_WRITE( "stat(buf)", arg2, sizeof(struct vki_statfs) );
}
POST(fstatfs)
{
- VG_TRACK( post_mem_write, arg2, sizeof(struct vki_statfs) );
+ POST_MEM_WRITE( arg2, sizeof(struct vki_statfs) );
}
PRE(fstatfs64)
{
/* int fstatfs64(int fd, size_t sz, struct statfs *buf); */
- MAYBE_PRINTF("fstatfs64 ( %d, %llu, %p )\n",arg1,(ULong)arg2,arg3);
- SYSCALL_TRACK( pre_mem_write, tid, "stat(buf)", arg3, arg2 );
+ PRINT("fstatfs64 ( %d, %llu, %p )",arg1,(ULong)arg2,arg3);
+ PRE_MEM_WRITE( "stat(buf)", arg3, arg2 );
}
POST(fstatfs64)
{
- VG_TRACK( post_mem_write, arg3, arg2 );
+ POST_MEM_WRITE( arg3, arg2 );
}
PRE(getsid)
{
/* pid_t getsid(pid_t pid); */
- MAYBE_PRINTF("getsid ( %d )\n", arg1);
+ PRINT("getsid ( %d )", arg1);
}
PRE(pread64)
{
/* ssize_t pread64(int fd, void *buf, size_t count, loff_t offset); */
- MAYBE_PRINTF("pread ( %d, %p, %llu, %lld )\n",
- arg1, arg2, (ULong)arg3, arg4|((ULong) arg5 << 32));
- SYSCALL_TRACK( pre_mem_write, tid, "pread(buf)", arg2, arg3 );
+ PRINT("pread ( %d, %p, %llu, %lld )",
+ arg1, arg2, (ULong)arg3, LOHI64(arg4,arg5));
+ PRE_MEM_WRITE( "pread(buf)", arg2, arg3 );
}
POST(pread64)
{
- MAYBE_PRINTF("SYSCALL[%d] pread ( %d, %p, %d, %d ) --> %d\n",
- VG_(getpid)(),
- arg1, arg2, arg3, arg4, res);
if (res > 0) {
- VG_TRACK( post_mem_write, arg2, res );
+ POST_MEM_WRITE( arg2, res );
}
}
PRE(mknod)
{
/* int mknod(const char *pathname, mode_t mode, dev_t dev); */
- MAYBE_PRINTF("mknod ( %p, 0x%x, 0x%x )\n", arg1, arg2, arg3 );
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "mknod(pathname)", arg1 );
+ PRINT("mknod ( %p, 0x%x, 0x%x )", arg1, arg2, arg3 );
+ PRE_MEM_RASCIIZ( "mknod(pathname)", arg1 );
}
PRE(flock)
{
/* int flock(int fd, int operation); */
- MAYBE_PRINTF("flock ( %d, %d )\n", arg1, arg2 );
+ PRINT("flock ( %d, %d )", arg1, arg2 );
}
PRE(init_module)
{
/* int init_module(const char *name, struct module *image); */
- MAYBE_PRINTF("init_module ( %p, %p )\n", arg1, arg2 );
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "init_module(name)", arg1 );
- SYSCALL_TRACK( pre_mem_read, tid, "init_module(image)", arg2,
- VKI_SIZEOF_STRUCT_MODULE );
+ PRINT("init_module ( %p, %p )", arg1, arg2 );
+ PRE_MEM_RASCIIZ( "init_module(name)", arg1 );
+ PRE_MEM_READ( "init_module(image)", arg2, VKI_SIZEOF_STRUCT_MODULE );
}
PRE(ioperm)
{
/* int ioperm(unsigned long from, unsigned long num, int turn_on); */
- MAYBE_PRINTF("ioperm ( %d, %d, %d )\n", arg1, arg2, arg3 );
+ PRINT("ioperm ( %d, %d, %d )", arg1, arg2, arg3 );
}
PRE(capget)
{
/* int capget(cap_user_header_t header, cap_user_data_t data); */
- MAYBE_PRINTF("capget ( %p, %p )\n", arg1, arg2 );
- SYSCALL_TRACK( pre_mem_read, tid, "capget(header)", arg1,
+ PRINT("capget ( %p, %p )", arg1, arg2 );
+ PRE_MEM_READ( "capget(header)", arg1,
sizeof(struct __vki_user_cap_header_struct) );
- SYSCALL_TRACK( pre_mem_write, tid, "capget(data)", arg2,
+ PRE_MEM_WRITE( "capget(data)", arg2,
sizeof(struct __vki_user_cap_data_struct) );
}
POST(capget)
{
if (arg2 != (Addr)NULL)
- VG_TRACK( post_mem_write, arg2, sizeof(struct __vki_user_cap_data_struct) );
+ POST_MEM_WRITE( arg2, sizeof(struct __vki_user_cap_data_struct) );
}
PRE(capset)
{
- SYSCALL_TRACK( pre_mem_read, tid, "capset(header)",
+ PRE_MEM_READ( "capset(header)",
arg1, sizeof(struct __vki_user_cap_header_struct) );
- SYSCALL_TRACK( pre_mem_read, tid, "capset(data)",
+ PRE_MEM_READ( "capset(data)",
arg2, sizeof(struct __vki_user_cap_data_struct) );
}
@@ -1721,7 +1705,7 @@
Addr a_deref = deref_Addr( tid, a, s1 );
if (0 == a_deref)
break;
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, s2, a_deref );
+ PRE_MEM_RASCIIZ( s2, a_deref );
a += sizeof(char*);
}
}
@@ -1731,9 +1715,9 @@
/* int execve (const char *filename,
char *const argv [],
char *const envp[]); */
- MAYBE_PRINTF("execve ( %p(%s), %p, %p )\n", arg1, arg1, arg2, arg3);
+ PRINT("execve ( %p(%s), %p, %p )", arg1, arg1, arg2, arg3);
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "execve(filename)", arg1 );
+ PRE_MEM_RASCIIZ( "execve(filename)", arg1 );
if (arg2 != (UWord)NULL)
pre_argv_envp( arg2, tid, "execve(argv)", "execve(argv[i])" );
if (arg3 != (UWord)NULL)
@@ -1839,14 +1823,14 @@
PRE(access)
{
/* int access(const char *pathname, int mode); */
- MAYBE_PRINTF("access ( %p(%s), %d )\n", arg1,arg1,arg2);
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "access(pathname)", arg1 );
+ PRINT("access ( %p(%s), %d )", arg1,arg1,arg2);
+ PRE_MEM_RASCIIZ( "access(pathname)", arg1 );
}
PRE(alarm)
{
/* unsigned int alarm(unsigned int seconds); */
- MAYBE_PRINTF("alarm ( %d )\n", arg1);
+ PRINT("alarm ( %d )", arg1);
}
PRE(brk)
@@ -1868,12 +1852,10 @@
Both will seg fault if you shrink it back into a text segment.
*/
- MAYBE_PRINTF("brk ( %p ) --> ",arg1);
+ PRINT("brk ( %p )",arg1);
set_result( do_brk(arg1) );
- MAYBE_PRINTF("0x%x\n", res);
-
if (res == arg1) {
/* brk() succeeded */
if (res < brk_limit) {
@@ -1895,22 +1877,22 @@
PRE(chdir)
{
/* int chdir(const char *path); */
- MAYBE_PRINTF("chdir ( %p )\n", arg1);
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "chdir(path)", arg1 );
+ PRINT("chdir ( %p )", arg1);
+ PRE_MEM_RASCIIZ( "chdir(path)", arg1 );
}
PRE(chmod)
{
/* int chmod(const char *path, mode_t mode); */
- MAYBE_PRINTF("chmod ( %p, %d )\n", arg1,arg2);
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "chmod(path)", arg1 );
+ PRINT("chmod ( %p, %d )", arg1,arg2);
+ PRE_MEM_RASCIIZ( "chmod(path)", arg1 );
}
PRE(chown)
{
/* int chown(const char *path, uid_t owner, gid_t group); */
- MAYBE_PRINTF("chown ( %p, 0x%x, 0x%x )\n", arg1,arg2,arg3);
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "chown(path)", arg1 );
+ PRINT("chown ( %p, 0x%x, 0x%x )", arg1,arg2,arg3);
+ PRE_MEM_RASCIIZ( "chown(path)", arg1 );
}
PREALIAS(chown32, chown);
@@ -1919,7 +1901,7 @@
PRE(close)
{
/* int close(int fd); */
- MAYBE_PRINTF("close ( %d )\n",arg1);
+ PRINT("close ( %d )",arg1);
/* Detect and negate attempts by the client to close Valgrind's log fd */
if (!fd_allowed(arg1, "close", tid, False))
set_result( -VKI_EBADF );
@@ -1933,12 +1915,12 @@
PRE(dup)
{
/* int dup(int oldfd); */
- MAYBE_PRINTF("dup ( %d ) --> ", arg1);
+ PRINT("dup ( %d ) --> ", arg1);
}
POST(dup)
{
- MAYBE_PRINTF("%d\n", res);
+ PRINT("%d\n", res);
if (!fd_allowed(res, "dup", tid, True)) {
VG_(close)(res);
set_result( -VKI_EMFILE );
@@ -1951,16 +1933,13 @@
PRE(dup2)
{
/* int dup2(int oldfd, int newfd); */
- MAYBE_PRINTF("dup2 ( %d, %d ) ...\n", arg1,arg2);
+ PRINT("dup2 ( %d, %d )", arg1,arg2);
if (!fd_allowed(arg2, "dup2", tid, True))
set_result( -VKI_EBADF );
}
POST(dup2)
{
- MAYBE_PRINTF("SYSCALL[%d] dup2 ( %d, %d ) = %d\n",
- VG_(getpid)(),
- arg1, arg2, res);
if(VG_(clo_track_fds))
record_fd_open(tid, res, VG_(resolve_filename)(res));
}
@@ -1968,7 +1947,7 @@
PRE(fcntl)
{
/* int fcntl(int fd, int cmd, int arg); */
- MAYBE_PRINTF("fcntl ( %d, %d, %d )\n",arg1,arg2,arg3);
+ PRINT("fcntl ( %d, %d, %d )",arg1,arg2,arg3);
if (arg2 == VKI_F_SETLKW)
tst->sys_flags |= MayBlock;
}
@@ -1989,13 +1968,13 @@
PRE(fchdir)
{
/* int fchdir(int fd); */
- MAYBE_PRINTF("fchdir ( %d )\n", arg1);
+ PRINT("fchdir ( %d )", arg1);
}
PRE(fchown)
{
/* int fchown(int filedes, uid_t owner, gid_t group); */
- MAYBE_PRINTF("fchown ( %d, %d, %d )\n", arg1,arg2,arg3);
+ PRINT("fchown ( %d, %d, %d )", arg1,arg2,arg3);
}
PREALIAS(fchown32, fchown);
@@ -2003,13 +1982,13 @@
PRE(fchmod)
{
/* int fchmod(int fildes, mode_t mode); */
- MAYBE_PRINTF("fchmod ( %d, %d )\n", arg1,arg2);
+ PRINT("fchmod ( %d, %d )", arg1,arg2);
}
PRE(fcntl64)
{
/* int fcntl64(int fd, int cmd, int arg); */
- MAYBE_PRINTF("fcntl64 ( %d, %d, %d )\n", arg1,arg2,arg3);
+ PRINT("fcntl64 ( %d, %d, %d )", arg1,arg2,arg3);
if (arg2 == VKI_F_SETLKW || arg2 == VKI_F_SETLKW64)
tst->sys_flags |= MayBlock;
}
@@ -2030,13 +2009,13 @@
PRE(fstat)
{
/* int fstat(int filedes, struct stat *buf); */
- MAYBE_PRINTF("fstat ( %d, %p )\n",arg1,arg2);
- SYSCALL_TRACK( pre_mem_write, tid, "fstat", arg2, sizeof(struct vki_stat) );
+ PRINT("fstat ( %d, %p )",arg1,arg2);
+ PRE_MEM_WRITE( "fstat", arg2, sizeof(struct vki_stat) );
}
POST(fstat)
{
- VG_TRACK( post_mem_write, arg2, sizeof(struct vki_stat) );
+ POST_MEM_WRITE( arg2, sizeof(struct vki_stat) );
}
static vki_sigset_t fork_saved_mask;
@@ -2053,7 +2032,7 @@
VG_(sigprocmask)(VKI_SIG_SETMASK, &mask, &fork_saved_mask);
/* pid_t fork(void); */
- MAYBE_PRINTF("fork ()\n");
+ PRINT("fork ()");
do_atfork_pre(tid);
}
@@ -2073,7 +2052,7 @@
/* restore signal mask */
VG_(sigprocmask)(VKI_SIG_SETMASK, &fork_saved_mask, NULL);
} else {
- MAYBE_PRINTF(" fork: process %d created child %d\n", VG_(main_pid), res);
+ PRINT(" fork: process %d created child %d\n", VG_(main_pid), res);
do_atfork_parent(tid);
@@ -2084,7 +2063,7 @@
PRE(clone)
{
- MAYBE_PRINTF("clone ( %d, %p, %p, %p, %p )\n",arg1,arg2,arg3,arg4,arg5);
+ PRINT("clone ( %d, %p, %p, %p, %p )",arg1,arg2,arg3,arg4,arg5);
if (arg2 == 0 &&
(arg1 == (VKI_CLONE_CHILD_CLEARTID|VKI_CLONE_CHILD_SETTID|VKI_SIGCHLD)
@@ -2105,63 +2084,61 @@
PRE(fsync)
{
/* int fsync(int fd); */
- MAYBE_PRINTF("fsync ( %d )\n", arg1);
+ PRINT("fsync ( %d )", arg1);
}
PRE(ftruncate)
{
/* int ftruncate(int fd, size_t length); */
- MAYBE_PRINTF("ftruncate ( %d, %lld )\n", arg1,(ULong)arg2);
+ PRINT("ftruncate ( %d, %lld )", arg1,(ULong)arg2);
}
PRE(ftruncate64)
{
/* int ftruncate64(int fd, off64_t length); */
- MAYBE_PRINTF("ftruncate64 ( %d, %lld )\n",
- arg1,arg2|((long long) arg3 << 32));
+ PRINT("ftruncate64 ( %d, %lld )", arg1, LOHI64(arg2,arg3));
}
PRE(getdents)
{
/* int getdents(unsigned int fd, struct dirent *dirp,
unsigned int count); */
- MAYBE_PRINTF("getdents ( %d, %p, %d )\n",arg1,arg2,arg3);
- SYSCALL_TRACK( pre_mem_write, tid, "getdents(dirp)", arg2, arg3 );
+ PRINT("getdents ( %d, %p, %d )",arg1,arg2,arg3);
+ PRE_MEM_WRITE( "getdents(dirp)", arg2, arg3 );
}
POST(getdents)
{
if (res > 0)
- VG_TRACK( post_mem_write, arg2, res );
+ POST_MEM_WRITE( arg2, res );
}
PRE(getdents64)
{
/* int getdents(unsigned int fd, struct dirent64 *dirp,
unsigned int count); */
- MAYBE_PRINTF("getdents64 ( %d, %p, %d )\n",arg1,arg2,arg3);
- SYSCALL_TRACK( pre_mem_write, tid, "getdents64(dirp)", arg2, arg3 );
+ PRINT("getdents64 ( %d, %p, %d )",arg1,arg2,arg3);
+ PRE_MEM_WRITE( "getdents64(dirp)", arg2, arg3 );
}
POST(getdents64)
{
if (res > 0)
- VG_TRACK( post_mem_write, arg2, res );
+ POST_MEM_WRITE( arg2, res );
}
PRE(getgroups)
{
/* int getgroups(int size, gid_t list[]); */
- MAYBE_PRINTF("getgroups ( %d, %p )\n", arg1, arg2);
+ PRINT("getgroups ( %d, %p )", arg1, arg2);
if (arg1 > 0)
- SYSCALL_TRACK( pre_mem_write, tid, "getgroups(list)", arg2,
- arg1 * sizeof(vki_gid_t) );
+ PRE_MEM_WRITE( "getgroups(list)", arg2, arg1 * sizeof(vki_gid_t) );
}
POST(getgroups)
{
if (arg1 > 0 && res > 0)
- VG_TRACK( post_mem_write, arg2, res * sizeof(vki_gid_t) );
+ POST_MEM_WRITE( arg2, res * sizeof(vki_gid_t) );
}
PREALIAS(getgroups32, getgroups);
@@ -2172,171 +2149,158 @@
// Note that this prototype is the kernel one, with a different return
// type to the glibc one!
/* long getcwd(char *buf, size_t size); */
- MAYBE_PRINTF("getcwd ( %p, %llu )\n",arg1,(ULong)arg2);
- SYSCALL_TRACK( pre_mem_write, tid, "getcwd(buf)", arg1, arg2 );
+ PRINT("getcwd ( %p, %llu )",arg1,(ULong)arg2);
+ PRE_MEM_WRITE( "getcwd(buf)", arg1, arg2 );
}
POST(getcwd)
{
if (res != (Addr)NULL)
- VG_TRACK( post_mem_write, arg1, res );
+ POST_MEM_WRITE( arg1, res );
}
PRE(geteuid)
{
/* uid_t geteuid(void); */
- MAYBE_PRINTF("geteuid ( )\n");
+ PRINT("geteuid ( )");
}
PRE(geteuid32)
{
/* ?? uid_t geteuid32(void); */
- MAYBE_PRINTF("geteuid32(?) ( )\n");
+ PRINT("geteuid32(?) ( )");
}
PRE(getegid)
{
/* gid_t getegid(void); */
- MAYBE_PRINTF("getegid ()\n");
+ PRINT("getegid ()");
}
PRE(getegid32)
{
/* gid_t getegid32(void); */
- MAYBE_PRINTF("getegid32 ()\n");
+ PRINT("getegid32 ()");
}
PRE(getgid)
{
/* gid_t getgid(void); */
- MAYBE_PRINTF("getgid ()\n");
+ PRINT("getgid ()");
}
PRE(getgid32)
{
/* gid_t getgid32(void); */
- MAYBE_PRINTF("getgid32 ()\n");
+ PRINT("getgid32 ()");
}
PRE(getpid)
{
/* pid_t getpid(void); */
- MAYBE_PRINTF("getpid ()\n");
+ PRINT("getpid ()");
}
PRE(getpgid)
{
/* pid_t getpgid(pid_t pid); */
- MAYBE_PRINTF("getpgid ( %d )\n", arg1);
+ PRINT("getpgid ( %d )", arg1);
}
PRE(getpgrp)
{
/* pid_t getpgrp(void); */
- MAYBE_PRINTF("getpgrp ()\n");
+ PRINT("getpgrp ()");
}
PRE(getppid)
{
/* pid_t getppid(void); */
- MAYBE_PRINTF("getppid ()\n");
+ PRINT("getppid ()");
}
PRE(getresgid)
{
/* int getresgid(gid_t *rgid, gid_t *egid, gid_t *sgid); */
- MAYBE_PRINTF("getresgid ( %p, %p, %p )\n", arg1,arg2,arg3);
- SYSCALL_TRACK( pre_mem_write, tid, "getresgid(rgid)",
- arg1, sizeof(vki_gid_t) );
- SYSCALL_TRACK( pre_mem_write, tid, "getresgid(egid)",
- arg2, sizeof(vki_gid_t) );
- SYSCALL_TRACK( pre_mem_write, tid, "getresgid(sgid)",
- arg3, sizeof(vki_gid_t) );
+ PRINT("getresgid ( %p, %p, %p )", arg1,arg2,arg3);
+ PRE_MEM_WRITE( "getresgid(rgid)", arg1, sizeof(vki_gid_t) );
+ PRE_MEM_WRITE( "getresgid(egid)", arg2, sizeof(vki_gid_t) );
+ PRE_MEM_WRITE( "getresgid(sgid)", arg3, sizeof(vki_gid_t) );
}
POST(getresgid)
{
if (res == 0) {
- VG_TRACK( post_mem_write, arg1, sizeof(vki_gid_t) );
- VG_TRACK( post_mem_write, arg2, sizeof(vki_gid_t) );
- VG_TRACK( post_mem_write, arg3, sizeof(vki_gid_t) );
+ POST_MEM_WRITE( arg1, sizeof(vki_gid_t) );
+ POST_MEM_WRITE( arg2, sizeof(vki_gid_t) );
+ POST_MEM_WRITE( arg3, sizeof(vki_gid_t) );
}
}
PRE(getresgid32)
{
/* int getresgid(gid_t *rgid, gid_t *egid, gid_t *sgid); */
- MAYBE_PRINTF("getresgid32 ( %p, %p, %p )\n", arg1,arg2,arg3);
- SYSCALL_TRACK( pre_mem_write, tid, "getresgid32(rgid)",
- arg1, sizeof(vki_gid_t) );
- SYSCALL_TRACK( pre_mem_write, tid, "getresgid32(egid)",
- arg2, sizeof(vki_gid_t) );
- SYSCALL_TRACK( pre_mem_write, tid, "getresgid32(sgid)",
- arg3, sizeof(vki_gid_t) );
+ PRINT("getresgid32 ( %p, %p, %p )", arg1,arg2,arg3);
+ PRE_MEM_WRITE( "getresgid32(rgid)", arg1, sizeof(vki_gid_t) );
+ PRE_MEM_WRITE( "getresgid32(egid)", arg2, sizeof(vki_gid_t) );
+ PRE_MEM_WRITE( "getresgid32(sgid)", arg3, sizeof(vki_gid_t) );
}
POST(getresgid32)
{
if (res == 0) {
- VG_TRACK( post_mem_write, arg1, sizeof(vki_gid_t) );
- VG_TRACK( post_mem_write, arg2, sizeof(vki_gid_t) );
- VG_TRACK( post_mem_write, arg3, sizeof(vki_gid_t) );
+ POST_MEM_WRITE( arg1, sizeof(vki_gid_t) );
+ POST_MEM_WRITE( arg2, sizeof(vki_gid_t) );
+ POST_MEM_WRITE( arg3, sizeof(vki_gid_t) );
}
}
PRE(getresuid)
{
/* int getresuid(uid_t *ruid, uid_t *euid, uid_t *suid); */
- MAYBE_PRINTF("getresuid ( %p, %p, %p )\n", arg1,arg2,arg3);
- SYSCALL_TRACK( pre_mem_write, tid, "getresuid(ruid)",
- arg1, sizeof(vki_uid_t) );
- SYSCALL_TRACK( pre_mem_write, tid, "getresuid(euid)",
- arg2, sizeof(vki_uid_t) );
- SYSCALL_TRACK( pre_mem_write, tid, "getresuid(suid)",
- arg3, sizeof(vki_uid_t) );
+ PRINT("getresuid ( %p, %p, %p )", arg1,arg2,arg3);
+ PRE_MEM_WRITE( "getresuid(ruid)", arg1, sizeof(vki_uid_t) );
+ PRE_MEM_WRITE( "getresuid(euid)", arg2, sizeof(vki_uid_t) );
+ PRE_MEM_WRITE( "getresuid(suid)", arg3, sizeof(vki_uid_t) );
}
POST(getresuid)
{
if (res == 0) {
- VG_TRACK( post_mem_write, arg1, sizeof(vki_uid_t) );
- VG_TRACK( post_mem_write, arg2, sizeof(vki_uid_t) );
- VG_TRACK( post_mem_write, arg3, sizeof(vki_uid_t) );
+ POST_MEM_WRITE( arg1, sizeof(vki_uid_t) );
+ POST_MEM_WRITE( arg2, sizeof(vki_uid_t) );
+ POST_MEM_WRITE( arg3, sizeof(vki_uid_t) );
}
}
PRE(getresuid32)
{
/* int getresuid(uid_t *ruid, uid_t *euid, uid_t *suid); */
- MAYBE_PRINTF("getresuid32 ( %p, %p, %p )\n", arg1,arg2,arg3);
- SYSCALL_TRACK( pre_mem_write, tid, "getresuid32(ruid)",
- arg1, sizeof(vki_uid_t) );
- SYSCALL_TRACK( pre_mem_write, tid, "getresuid32(euid)",
- arg2, sizeof(vki_uid_t) );
- SYSCALL_TRACK( pre_mem_write, tid, "getresuid32(suid)",
- arg3, sizeof(vki_uid_t) );
+ PRINT("getresuid32 ( %p, %p, %p )", arg1,arg2,arg3);
+ PRE_MEM_WRITE( "getresuid32(ruid)", arg1, sizeof(vki_uid_t) );
+ PRE_MEM_WRITE( "getresuid32(euid)", arg2, sizeof(vki_uid_t) );
+ PRE_MEM_WRITE( "getresuid32(suid)", arg3, sizeof(vki_uid_t) );
}
POST(getresuid32)
{
if (res == 0) {
- VG_TRACK( post_mem_write, arg1, sizeof(vki_uid_t) );
- VG_TRACK( post_mem_write, arg2, sizeof(vki_uid_t) );
- VG_TRACK( post_mem_write, arg3, sizeof(vki_uid_t) );
+ POST_MEM_WRITE( arg1, sizeof(vki_uid_t) );
+ POST_MEM_WRITE( arg2, sizeof(vki_uid_t) );
+ POST_MEM_WRITE( arg3, sizeof(vki_uid_t) );
}
}
PRE(getrlimit)
{
/* int getrlimit (int resource, struct rlimit *rlim); */
- MAYBE_PRINTF("getrlimit ( %d, %p )\n", arg1,arg2);
- SYSCALL_TRACK( pre_mem_write, tid, "getrlimit(rlim)", arg2,
- sizeof(struct vki_rlimit) );
+ PRINT("getrlimit ( %d, %p )", arg1,arg2);
+ PRE_MEM_WRITE( "getrlimit(rlim)", arg2, sizeof(struct vki_rlimit) );
}
POST(getrlimit)
{
- VG_TRACK( post_mem_write, arg2, sizeof(struct vki_rlimit) );
+ POST_MEM_WRITE( arg2, sizeof(struct vki_rlimit) );
switch(arg1) {
case VKI_RLIMIT_NOFILE:
@@ -2360,9 +2324,8 @@
PRE(getrusage)
{
/* int getrusage (int who, struct rusage *usage); */
- MAYBE_PRINTF("getrusage ( %d, %p )\n", arg1,arg2);
- SYSCALL_TRACK( pre_mem_write, tid, "getrusage(usage)", arg2,
- sizeof(struct vki_rusage) );
+ PRINT("getrusage ( %d, %p )", arg1,arg2);
+ PRE_MEM_WRITE( "getrusage(usage)", arg2, sizeof(struct vki_rusage) );
}
POST(getrusage)
@@ -2374,43 +2337,39 @@
PRE(gettimeofday)
{
/* int gettimeofday(struct timeval *tv, struct timezone *tz); */
- MAYBE_PRINTF("gettimeofday ( %p, %p )\n",arg1,arg2);
- SYSCALL_TRACK( pre_mem_write, tid, "gettimeofday(tv)", arg1,
- sizeof(struct vki_timeval) );
+ PRINT("gettimeofday ( %p, %p )",arg1,arg2);
+ PRE_MEM_WRITE( "gettimeofday(tv)", arg1, sizeof(struct vki_timeval) );
if (arg2 != 0)
- SYSCALL_TRACK( pre_mem_write, tid, "gettimeofday(tz)", arg2,
- sizeof(struct vki_timezone) );
+ PRE_MEM_WRITE( "gettimeofday(tz)", arg2, sizeof(struct vki_timezone) );
}
POST(gettimeofday)
{
if (res == 0) {
- VG_TRACK( post_mem_write, arg1, sizeof(struct vki_timeval) );
+ POST_MEM_WRITE( arg1, sizeof(struct vki_timeval) );
if (arg2 != 0)
- VG_TRACK( post_mem_write, arg2, sizeof(struct vki_timezone) );
+ POST_MEM_WRITE( arg2, sizeof(struct vki_timezone) );
}
}
PRE(getuid)
{
/* uid_t getuid(void); */
- MAYBE_PRINTF("getuid ( )\n");
+ PRINT("getuid ( )");
}
PRE(getuid32)
{
/* ???uid_t getuid32(void); */
- MAYBE_PRINTF("getuid32 ( )\n");
+ PRINT("getuid32 ( )");
}
PRE(ipc)
{
- MAYBE_PRINTF("ipc ( %d, %d, %d, %d, %p, %d )\n",
- arg1,arg2,arg3,arg4,arg5,arg6);
+ PRINT("ipc ( %d, %d, %d, %d, %p, %d )", arg1,arg2,arg3,arg4,arg5,arg6);
switch (arg1 /* call */) {
case 1: /* IPCOP_semop */
- SYSCALL_TRACK( pre_mem_read, tid, "semop(sops)", arg5,
- arg3 * sizeof(struct vki_sembuf) );
+ PRE_MEM_READ( "semop(sops)", arg5, arg3 * sizeof(struct vki_sembuf) );
tst->sys_flags |= MayBlock;
break;
case 2: /* IPCOP_semget */
@@ -2423,7 +2382,7 @@
case VKI_SEM_INFO:
{
Addr buf = deref_Addr( tid, (Addr)&arg->__buf, "semctl(IPC_INFO, arg)" );
- SYSCALL_TRACK( pre_mem_write, tid, "semctl(IPC_INFO, arg->buf)", buf,
+ PRE_MEM_WRITE( "semctl(IPC_INFO, arg->buf)", buf,
sizeof(struct vki_seminfo) );
break;
}
@@ -2431,14 +2390,14 @@
case VKI_SEM_STAT:
{
Addr buf = deref_Addr( tid, (Addr)&arg->buf, "semctl(IPC_STAT, arg)" );
- SYSCALL_TRACK( pre_mem_write, tid, "semctl(IPC_STAT, arg->buf)", buf,
+ PRE_MEM_WRITE( "semctl(IPC_STAT, arg->buf)", buf,
sizeof(struct vki_semid_ds) );
break;
}
case VKI_IPC_SET:
{
Addr buf = deref_Addr( tid, (Addr)&arg->buf, "semctl(IPC_SET, arg)" );
- SYSCALL_TRACK( pre_mem_read, tid, "semctl(IPC_SET, arg->buf)", buf,
+ PRE_MEM_READ( "semctl(IPC_SET, arg->buf)", buf,
sizeof(struct vki_semid_ds) );
break;
}
@@ -2446,7 +2405,7 @@
{
Addr array = deref_Addr( tid, (Addr)&arg->array, "semctl(IPC_GETALL, arg)" );
UInt nsems = get_sem_count( arg2 );
- SYSCALL_TRACK( pre_mem_write, tid, "semctl(IPC_GETALL, arg->array)", array,
+ PRE_MEM_WRITE( "semctl(IPC_GETALL, arg->array)", array,
sizeof(short) * nsems );
break;
}
@@ -2454,13 +2413,13 @@
{
Addr array = deref_Addr( tid, (Addr)&arg->array, "semctl(IPC_SETALL, arg)" );
UInt nsems = get_sem_count( arg2 );
- SYSCALL_TRACK( pre_mem_read, tid, "semctl(IPC_SETALL, arg->array)", array,
+ PRE_MEM_READ( "semctl(IPC_SETALL, arg->array)", array,
sizeof(short) * nsems );
break;
}
case VKI_SETVAL:
{
- SYSCALL_TRACK( pre_mem_read, tid, "semctl(IPC_SETVAL, arg->array)",
+ PRE_MEM_READ( "semctl(IPC_SETVAL, arg->array)",
(Addr)&arg->val, sizeof(arg->val) );
break;
}
@@ -2468,7 +2427,7 @@
case VKI_SEM_INFO|VKI_IPC_64:
{
Addr buf = deref_Addr( tid, (Addr)&arg->__buf, "semctl(IPC_INFO, arg)" );
- SYSCALL_TRACK( pre_mem_write, tid, "semctl(IPC_INFO, arg->buf)", buf,
+ PRE_MEM_WRITE( "semctl(IPC_INFO, arg->buf)", buf,
sizeof(struct vki_seminfo) );
break;
}
@@ -2476,14 +2435,14 @@
case VKI_SEM_STAT|VKI_IPC_64:
{
Addr buf = deref_Addr( tid, (Addr)&arg->buf, "semctl(IPC_STAT, arg)" );
- SYSCALL_TRACK( pre_mem_write, tid, "semctl(IPC_STAT, arg->buf)", buf,
+ PRE_MEM_WRITE( "semctl(IPC_STAT, arg->buf)", buf,
sizeof(struct vki_semid64_ds) );
break;
}
case VKI_IPC_SET|VKI_IPC_64:
{
Addr buf = deref_Addr( tid, (Addr)&arg->buf, "semctl(IPC_SET, arg)" );
- SYSCALL_TRACK( pre_mem_read, tid, "semctl(IPC_SET, arg->buf)", buf,
+ PRE_MEM_READ( "semctl(IPC_SET, arg->buf)", buf,
sizeof(struct vki_semid64_ds) );
break;
}
@@ -2491,7 +2450,7 @@
{
Addr array = deref_Addr( tid, (Addr)&arg->array, "semctl(IPC_GETALL, arg)" );
UInt nsems = get_sem_count( arg2 );
- SYSCALL_TRACK( pre_mem_write, tid, "semctl(IPC_GETALL, arg->array)", array,
+ PRE_MEM_WRITE( "semctl(IPC_GETALL, arg->array)", array,
sizeof(short) * nsems );
break;
}
@@ -2499,13 +2458,13 @@
{
Addr array = deref_Addr( tid, (Addr)&arg->array, "semctl(IPC_SETALL, arg)" );
UInt nsems = get_sem_count( arg2 );
- SYSCALL_TRACK( pre_mem_read, tid, "semctl(IPC_SETALL, arg->array)", array,
+ PRE_MEM_READ( "semctl(IPC_SETALL, arg->array)", array,
sizeof(short) * nsems );
break;
}
case VKI_SETVAL|VKI_IPC_64:
{
- SYSCALL_TRACK( pre_mem_read, tid, "semctl(IPC_SETVAL, arg->array)",
+ PRE_MEM_READ( "semctl(IPC_SETVAL, arg->array)",
(Addr)&arg->val, sizeof(arg->val) );
break;
}
@@ -2515,10 +2474,10 @@
break;
}
case 4: /* IPCOP_semtimedop */
- SYSCALL_TRACK( pre_mem_read, tid, "semtimedop(sops)", arg5,
+ PRE_MEM_READ( "semtimedop(sops)", arg5,
arg3 * sizeof(struct vki_sembuf) );
if (arg6 != (UWord)NULL)
- SYSCALL_TRACK( pre_mem_read, tid, "semtimedop(timeout)", arg6,
+ PRE_MEM_READ( "semtimedop(timeout)", arg6,
sizeof(struct vki_timespec) );
tst->sys_flags |= MayBlock;
break;
@@ -2527,9 +2486,9 @@
struct vki_msgbuf *msgp = (struct vki_msgbuf *)arg5;
Int msgsz = arg3;
- SYSCALL_TRACK( pre_mem_read, tid, "msgsnd(msgp->mtype)",
+ PRE_MEM_READ( "msgsnd(msgp->mtype)",
(Addr)&msgp->mtype, sizeof(msgp->mtype) );
- SYSCALL_TRACK( pre_mem_read, tid, "msgsnd(msgp->mtext)",
+ PRE_MEM_READ( "msgsnd(msgp->mtext)",
(Addr)msgp->mtext, msgsz );
if ((arg4 & VKI_IPC_NOWAIT) == 0)
@@ -2545,9 +2504,9 @@
(Addr) (&((struct vki_ipc_kludge *)arg5)->msgp),
"msgrcv(msgp)" );
- SYSCALL_TRACK( pre_mem_write, tid, "msgrcv(msgp->mtype)",
+ PRE_MEM_WRITE( "msgrcv(msgp->mtype)",
(Addr)&msgp->mtype, sizeof(msgp->mtype) );
- SYSCALL_TRACK( pre_mem_write, tid, "msgrcv(msgp->mtext)",
+ PRE_MEM_WRITE( "msgrcv(msgp->mtext)",
(Addr)msgp->mtext, msgsz );
if ((arg4 & VKI_IPC_NOWAIT) == 0)
@@ -2561,30 +2520,30 @@
switch (arg3 /* cmd */) {
case VKI_IPC_INFO:
case VKI_MSG_INFO:
- SYSCALL_TRACK( pre_mem_write, tid, "msgctl(IPC_INFO, buf)", arg5,
+ PRE_MEM_WRITE( "msgctl(IPC_INFO, buf)", arg5,
sizeof(struct vki_msginfo) );
break;
case VKI_IPC_STAT:
case VKI_MSG_STAT:
- SYSCALL_TRACK( pre_mem_write, tid, "msgctl(IPC_STAT, buf)", arg5,
+ PRE_MEM_WRITE( "msgctl(IPC_STAT, buf)", arg5,
sizeof(struct vki_msqid_ds) );
break;
case VKI_IPC_SET:
- SYSCALL_TRACK( pre_mem_read, tid, "msgctl(IPC_SET, buf)", arg5,
+ PRE_MEM_READ( "msgctl(IPC_SET, buf)", arg5,
sizeof(struct vki_msqid_ds) );
break;
case VKI_IPC_INFO|VKI_IPC_64:
case VKI_MSG_INFO|VKI_IPC_64:
- SYSCALL_TRACK( pre_mem_write, tid, "msgctl(IPC_INFO, buf)", arg5,
+ PRE_MEM_WRITE( "msgctl(IPC_INFO, buf)", arg5,
sizeof(struct vki_msginfo) );
break;
case VKI_IPC_STAT|VKI_IPC_64:
case VKI_MSG_STAT|VKI_IPC_64:
- SYSCALL_TRACK( pre_mem_write, tid, "msgctl(IPC_STAT, buf)", arg5,
+ PRE_MEM_WRITE( "msgctl(IPC_STAT, buf)", arg5,
sizeof(struct vki_msqid64_ds) );
break;
case VKI_IPC_SET|VKI_IPC_64:
- SYSCALL_TRACK( pre_mem_read, tid, "msgctl(IPC_SET, buf)", arg5,
+ PRE_MEM_READ( "msgctl(IPC_SET, buf)", arg5,
sizeof(struct vki_msqid64_ds) );
break;
default:
@@ -2615,37 +2574,37 @@
{
switch (arg3 /* cmd */) {
case VKI_IPC_INFO:
- SYSCALL_TRACK( pre_mem_write, tid, "shmctl(IPC_INFO, buf)", arg5,
+ PRE_MEM_WRITE( "shmctl(IPC_INFO, buf)", arg5,
sizeof(struct vki_shminfo) );
break;
case VKI_SHM_INFO:
- SYSCALL_TRACK( pre_mem_write, tid, "shmctl(SHM_INFO, buf)", arg5,
+ PRE_MEM_WRITE( "shmctl(SHM_INFO, buf)", arg5,
sizeof(struct vki_shm_info) );
break;
case VKI_IPC_STAT:
case VKI_SHM_STAT:
- SYSCALL_TRACK( pre_mem_write, tid, "shmctl(IPC_STAT, buf)", arg5,
+ PRE_MEM_WRITE( "shmctl(IPC_STAT, buf)", arg5,
sizeof(struct vki_shmid_ds) );
break;
case VKI_IPC_SET:
- SYSCALL_TRACK( pre_mem_read, tid, "shmctl(IPC_SET, buf)", arg5,
+ PRE_MEM_READ( "shmctl(IPC_SET, buf)", arg5,
sizeof(struct vki_shmid_ds) );
break;
case VKI_IPC_INFO|VKI_IPC_64:
- SYSCALL_TRACK( pre_mem_write, tid, "shmctl(IPC_INFO, buf)", arg5,
+ PRE_MEM_WRITE( "shmctl(IPC_INFO, buf)", arg5,
sizeof(struct vki_shminfo64) );
break;
case VKI_SHM_INFO|VKI_IPC_64:
- SYSCALL_TRACK( pre_mem_write, tid, "shmctl(SHM_INFO, buf)", arg5,
+ PRE_MEM_WRITE( "shmctl(SHM_INFO, buf)", arg5,
sizeof(struct vki_shm_info) );
break;
case VKI_IPC_STAT|VKI_IPC_64:
case VKI_SHM_STAT|VKI_IPC_64:
- SYSCALL_TRACK( pre_mem_write, tid, "shmctl(IPC_STAT, buf)", arg5,
+ PRE_MEM_WRITE( "shmctl(IPC_STAT, buf)", arg5,
sizeof(struct vki_shmid64_ds) );
break;
case VKI_IPC_SET|VKI_IPC_64:
- SYSCALL_TRACK( pre_mem_read, tid, "shmctl(IPC_SET, buf)", arg5,
+ PRE_MEM_READ( "shmctl(IPC_SET, buf)", arg5,
sizeof(struct vki_shmid_ds) );
break;
default:
@@ -2676,42 +2635,42 @@
case VKI_SEM_INFO:
{
Addr buf = deref_Addr( tid, (Addr)&arg->__buf, "semctl(arg)" );
- VG_TRACK( post_mem_write, buf, sizeof(struct vki_seminfo) );
+ POST_MEM_WRITE( buf, sizeof(struct vki_seminfo) );
break;
}
case VKI_IPC_STAT:
case VKI_SEM_STAT:
{
Addr buf = deref_Addr( tid, (Addr)&arg->buf, "semctl(arg)" );
- VG_TRACK( post_mem_write, buf, sizeof(struct vki_semid_ds) );
+ POST_MEM_WRITE( buf, sizeof(struct vki_semid_ds) );
break;
}
case VKI_GETALL:
{
Addr array = deref_Addr( tid, (Addr)&arg->array, "semctl(arg)" );
UInt nsems = get_sem_count( arg2 );
- VG_TRACK( post_mem_write, array, sizeof(short) * nsems );
+ POST_MEM_WRITE( array, sizeof(short) * nsems );
break;
}
case VKI_IPC_INFO|VKI_IPC_64:
case VKI_SEM_INFO|VKI_IPC_64:
{
Addr buf = deref_Addr( tid, (Addr)&arg->__buf, "semctl(arg)" );
- VG_TRACK( post_mem_write, buf, sizeof(struct vki_seminfo) );
+ POST_MEM_WRITE( buf, sizeof(struct vki_seminfo) );
break;
}
case VKI_IPC_STAT|VKI_IPC_64:
case VKI_SEM_STAT|VKI_IPC_64:
{
Addr buf = deref_Addr( tid, (Addr)&arg->buf, "semctl(arg)" );
- VG_TRACK( post_mem_write, buf, sizeof(struct vki_semid64_ds) );
+ POST_MEM_WRITE( buf, sizeof(struct vki_semid64_ds) );
break;
}
case VKI_GETALL|VKI_IPC_64:
{
Addr array = deref_Addr( tid, (Addr)&arg->array, "semctl(arg)" );
UInt nsems = get_sem_count( arg2 );
- VG_TRACK( post_mem_write, array, sizeof(short) * nsems );
+ POST_MEM_WRITE( array, sizeof(short) * nsems );
break;
}
default:
@@ -2731,9 +2690,8 @@
(Addr) (&((struct vki_ipc_kludge *)arg5)->msgp),
"msgrcv(msgp)" );
if ( res > 0 ) {
- VG_TRACK( post_mem_write, (Addr)&msgp->mtype,
- sizeof(msgp->mtype) );
- VG_TRACK( post_mem_write, (Addr)msgp->mtext, res );
+ POST_MEM_WRITE( (Addr)&msgp->mtype, sizeof(msgp->mtype) );
+ POST_MEM_WRITE( (Addr)msgp->mtext, res );
}
break;
}
@@ -2744,21 +2702,21 @@
switch (arg3 /* cmd */) {
case VKI_IPC_INFO:
case VKI_MSG_INFO:
- VG_TRACK( post_mem_write, arg5, sizeof(struct vki_msginfo) );
+ POST_MEM_WRITE( arg5, sizeof(struct vki_msginfo) );
break;
case VKI_IPC_STAT:
case VKI_MSG_STAT:
- VG_TRACK( post_mem_write, arg5, sizeof(struct vki_msqid_ds) );
+ POST_MEM_WRITE( arg5, sizeof(struct vki_msqid_ds) );
break;
case VKI_IPC_SET:
break;
case VKI_IPC_INFO|VKI_IPC_64:
case VKI_MSG_INFO|VKI_IPC_64:
- VG_TRACK( post_mem_write, arg5, sizeof(struct vki_msginfo) );
+ POST_MEM_WRITE( arg5, sizeof(struct vki_msginfo) );
break;
case VKI_IPC_STAT|VKI_IPC_64:
case VKI_MSG_STAT|VKI_IPC_64:
- VG_TRACK( post_mem_write, arg5, sizeof(struct vki_msqid64_ds) );
+ POST_MEM_WRITE( arg5, sizeof(struct vki_msqid64_ds) );
break;
case VKI_IPC_SET|VKI_IPC_64:
break;
@@ -2776,7 +2734,7 @@
/* force readability. before the syscall it is
* indeed uninitialized, as can be seen in
* glibc/sysdeps/unix/sysv/linux/shmat.c */
- VG_TRACK( post_mem_write, arg4, sizeof( ULong ) );
+ POST_MEM_WRITE( arg4, sizeof( ULong ) );
addr = deref_Addr ( tid, arg4, "shmat(addr)" );
if ( addr > 0 ) {
@@ -2810,24 +2768,24 @@
{
switch (arg3 /* cmd */) {
case VKI_IPC_INFO:
- VG_TRACK( post_mem_write, arg5, sizeof(struct vki_shminfo) );
+ POST_MEM_WRITE( arg5, sizeof(struct vki_shminfo) );
break;
case VKI_SHM_INFO:
- VG_TRACK( post_mem_write, arg5, sizeof(struct vki_shm_info) );
+ POST_MEM_WRITE( arg5, sizeof(struct vki_shm_info) );
break;
case VKI_IPC_STAT:
case VKI_SHM_STAT:
- VG_TRACK( post_mem_write, arg5, sizeof(struct vki_shmid_ds) );
+ POST_MEM_WRITE( arg5, sizeof(struct vki_shmid_ds) );
break;
case VKI_IPC_INFO|VKI_IPC_64:
- VG_TRACK( post_mem_write, arg5, sizeof(struct vki_shminfo64) );
+ POST_MEM_WRITE( arg5, sizeof(struct vki_shminfo64) );
break;
case VKI_SHM_INFO|VKI_IPC_64:
- VG_TRACK( post_mem_write, arg5, sizeof(struct vki_shm_info) );
+ POST_MEM_WRITE( arg5, sizeof(struct vki_shm_info) );
break;
case VKI_IPC_STAT|VKI_IPC_64:
case VKI_SHM_STAT|VKI_IPC_64:
- VG_TRACK( post_mem_write, arg5, sizeof(struct vki_shmid64_ds) );
+ POST_MEM_WRITE( arg5, sizeof(struct vki_shmid64_ds) );
break;
default:
break;
@@ -2855,26 +2813,26 @@
"is an IOCTL, request = 0x%x, d = %d, argp = 0x%x",
arg2,arg1,arg3);
*/
- MAYBE_PRINTF("ioctl ( %d, 0x%x, %p )\n",arg1,arg2,arg3);
+ PRINT("ioctl ( %d, 0x%x, %p )",arg1,arg2,arg3);
switch (arg2 /* request */) {
case VKI_TCSETS:
case VKI_TCSETSW:
case VKI_TCSETSF:
- SYSCALL_TRACK( pre_mem_read, tid, "ioctl(TCSET{S,SW,SF})", arg3,
+ PRE_MEM_READ( "ioctl(TCSET{S,SW,SF})", arg3,
sizeof(struct vki_termios) );
break;
case VKI_TCGETS:
- SYSCALL_TRACK( pre_mem_write, tid, "ioctl(TCGETS)", arg3,
+ PRE_MEM_WRITE( "ioctl(TCGETS)", arg3,
sizeof(struct vki_termios) );
break;
case VKI_TCSETA:
case VKI_TCSETAW:
case VKI_TCSETAF:
- SYSCALL_TRACK( pre_mem_read, tid, "ioctl(TCSET{A,AW,AF})", arg3,
+ PRE_MEM_READ( "ioctl(TCSET{A,AW,AF})", arg3,
sizeof(struct vki_termio) );
break;
case VKI_TCGETA:
- SYSCALL_TRACK( pre_mem_write, tid, "ioctl(TCGETA)", arg3,
+ PRE_MEM_WRITE( "ioctl(TCGETA)", arg3,
sizeof(struct vki_termio) );
break;
case VKI_TCSBRK:
@@ -2884,106 +2842,106 @@
/* These just take an int by value */
break;
case VKI_TIOCGWINSZ:
- SYSCALL_TRACK( pre_mem_write, tid, "ioctl(TIOCGWINSZ)", arg3,
+ PRE_MEM_WRITE( "ioctl(TIOCGWINSZ)", arg3,
sizeof(struct vki_winsize) );
break;
case VKI_TIOCSWINSZ:
- SYSCALL_TRACK( pre_mem_read, tid, "ioctl(TIOCSWINSZ)", arg3,
+ PRE_MEM_READ( "ioctl(TIOCSWINSZ)", arg3,
sizeof(struct vki_winsize) );
break;
case VKI_TIOCMBIS:
- SYSCALL_TRACK( pre_mem_read, tid, "ioctl(TIOCMBIS)", arg3,
+ PRE_MEM_READ( "ioctl(TIOCMBIS)", arg3,
sizeof(unsigned int) );
break;
case VKI_TIOCMBIC:
- SYSCALL_TRACK( pre_mem_read, tid, "ioctl(TIOCMBIC)", arg3,
+ PRE_MEM_READ( "ioctl(TIOCMBIC)", arg3,
sizeof(unsigned int) );
break;
case VKI_TIOCMSET:
- SYSCALL_TRACK( pre_mem_read, tid, "ioctl(TIOCMSET)", arg3,
+ PRE_MEM_READ( "ioctl(TIOCMSET)", arg3,
sizeof(unsigned int) );
break;
case VKI_TIOCLINUX:
- SYSCALL_TRACK( pre_mem_read, tid, "ioctl(TIOCLINUX)", arg3,
+ PRE_MEM_READ( "ioctl(TIOCLINUX)", arg3,
sizeof(char *) );
if (*(char *)arg3 == 11) {
- SYSCALL_TRACK( pre_mem_read, tid, "ioctl(TIOCLINUX, 11)",
+ PRE_MEM_READ( "ioctl(TIOCLINUX, 11)",
arg3, 2 * sizeof(char *) );
}
break;
case VKI_TIOCGPGRP:
/* Get process group ID for foreground processing group. */
- SYSCALL_TRACK( pre_mem_write, tid, "ioctl(TIOCGPGRP)", arg3,
+ PRE_MEM_WRITE( "ioctl(TIOCGPGRP)", arg3,
sizeof(vki_pid_t) );
break;
case VKI_TIOCSPGRP:
/* Set a process group ID? */
- SYSCALL_TRACK( pre_mem_write, tid, "ioctl(TIOCGPGRP)", arg3,
+ PRE_MEM_WRITE( "ioctl(TIOCGPGRP)", arg3,
sizeof(vki_pid_t) );
break;
case VKI_TIOCGPTN: /* Get Pty Number (of pty-mux device) */
- SYSCALL_TRACK( pre_mem_write, tid, "ioctl(TIOCGPTN)",
+ PRE_MEM_WRITE( "ioctl(TIOCGPTN)",
arg3, sizeof(int) );
break;
case VKI_TIOCSCTTY:
/* Just takes an int value. */
break;
case VKI_TIOCSPTLCK: /* Lock/unlock Pty */
- SYSCALL_TRACK( pre_mem_read, tid, "ioctl(TIOCSPTLCK)",
+ PRE_MEM_READ( "ioctl(TIOCSPTLCK)",
arg3, sizeof(int) );
break;
case VKI_FIONBIO:
- SYSCALL_TRACK( pre_mem_read, tid, "ioctl(FIONBIO)",
+ PRE_MEM_READ( "ioctl(FIONBIO)",
arg3, sizeof(int) );
break;
case VKI_FIOASYNC:
- SYSCALL_TRACK( pre_mem_read, tid, "ioctl(FIOASYNC)",
+ PRE_MEM_READ( "ioctl(FIOASYNC)",
arg3, sizeof(int) );
break;
case VKI_FIONREAD: /* identical to SIOCINQ */
- SYSCALL_TRACK( pre_mem_write, tid, "ioctl(FIONREAD)",
+ PRE_MEM_WRITE( "ioctl(FIONREAD)",
arg3, sizeof(int) );
break;
case VKI_SG_SET_COMMAND_Q:
- SYSCALL_TRACK( pre_mem_read, tid, "ioctl(SG_SET_COMMAND_Q)",
+ PRE_MEM_READ( "ioctl(SG_SET_COMMAND_Q)",
arg3, sizeof(int) );
break;
case VKI_SG_IO:
- SYSCALL_TRACK( pre_mem_write, tid, "ioctl(SG_IO)", arg3,
+ PRE_MEM_WRITE( "ioctl(SG_IO)", arg3,
sizeof(vki_sg_io_hdr_t) );
break;
case VKI_SG_GET_SCSI_ID:
- SYSCALL_TRACK( pre_mem_write, tid, "ioctl(SG_GET_SCSI_ID)", arg3,
+ PRE_MEM_WRITE( "ioctl(SG_GET_SCSI_ID)", arg3,
sizeof(vki_sg_scsi_id_t) );
break;
case VKI_SG_SET_RESERVED_SIZE:
- SYSCALL_TRACK( pre_mem_read, tid, "ioctl(SG_SET_RESERVED_SIZE)",
+ PRE_MEM_READ( "ioctl(SG_SET_RESERVED_SIZE)",
arg3, sizeof(int) );
break;
case VKI_SG_SET_TIMEOUT:
- SYSCALL_TRACK( pre_mem_read, tid, "ioctl(SG_SET_TIMEOUT)", arg3,
+ PRE_MEM_READ( "ioctl(SG_SET_TIMEOUT)", arg3,
sizeof(int) );
break;
case VKI_SG_GET_RESERVED_SIZE:
- SYSCALL_TRACK( pre_mem_write, tid,
+ PRE_MEM_WRITE(
"ioctl(SG_GET_RESERVED_SIZE)", arg3,
sizeof(int) );
break;
case VKI_SG_GET_TIMEOUT:
- SYSCALL_TRACK( pre_mem_write, tid, "ioctl(SG_GET_TIMEOUT)", arg3,
+ PRE_MEM_WRITE( "ioctl(SG_GET_TIMEOUT)", arg3,
sizeof(int) );
break;
case VKI_SG_GET_VERSION_NUM:
- SYSCALL_TRACK( pre_mem_read, tid, "ioctl(SG_GET_VERSION_NUM)",
+ PRE_MEM_READ( "ioctl(SG_GET_VERSION_NUM)",
arg3, sizeof(int) );
break;
case VKI_SG_EMULATED_HOST: /* 0x2203 */
- SYSCALL_TRACK( pre_mem_write, tid, "ioctl(SG_EMULATED_HOST)",
+ PRE_MEM_WRITE( "ioctl(SG_EMULATED_HOST)",
arg3, sizeof(int) );
break;
case VKI_SG_GET_SG_TABLESIZE: /* 0x227f */
- SYSCALL_TRACK( pre_mem_write, tid, "ioctl(SG_GET_SG_TABLESIZE)",
+ PRE_MEM_WRITE( "ioctl(SG_GET_SG_TABLESIZE)",
arg3, sizeof(int) );
break;
@@ -2993,130 +2951,128 @@
# ifndef ISDN_MAX_CHANNELS
# define ISDN_MAX_CHANNELS 64
# endif
- SYSCALL_TRACK( pre_mem_write, tid, "ioctl(IIOCGETCPS)", arg3,
+ PRE_MEM_WRITE( "ioctl(IIOCGETCPS)", arg3,
ISDN_MAX_CHANNELS
* 2 * sizeof(unsigned long) );
break;
case VKI_IIOCNETGPN:
- SYSCALL_TRACK( pre_mem_read, tid, "ioctl(IIOCNETGPN)",
+ PRE_MEM_READ( "ioctl(IIOCNETGPN)",
(Addr)&((vki_isdn_net_ioctl_phone *)arg3)->name,
sizeof(((vki_isdn_net_ioctl_phone *)arg3)->name) );
- SYSCALL_TRACK( pre_mem_write, tid, "ioctl(IIOCNETGPN)", arg3,
+ PRE_MEM_WRITE( "ioctl(IIOCNETGPN)", arg3,
sizeof(vki_isdn_net_ioctl_phone) );
break;
/* These all use struct ifreq AFAIK */
case VKI_SIOCGIFINDEX: /* get iface index */
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "ioctl(SIOCGIFINDEX)",
+ PRE_MEM_RASCIIZ( "ioctl(SIOCGIFINDEX)",
(Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
- SYSCALL_TRACK( pre_mem_write, tid, "ioctl(SIOCGIFINDEX)", arg3,
+ PRE_MEM_WRITE( "ioctl(SIOCGIFINDEX)", arg3,
sizeof(struct vki_ifreq));
break;
case VKI_SIOCGIFFLAGS: /* get flags */
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "ioctl(SIOCGIFFLAGS)",
+ PRE_MEM_RASCIIZ( "ioctl(SIOCGIFFLAGS)",
(Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
- SYSCALL_TRACK( pre_mem_write, tid, "ioctl(SIOCGIFFLAGS)", arg3,
+ PRE_MEM_WRITE( "ioctl(SIOCGIFFLAGS)", arg3,
sizeof(struct vki_ifreq));
break;
case VKI_SIOCGIFHWADDR: /* Get hardware address */
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "ioctl(SIOCGIFHWADDR)",
+ PRE_MEM_RASCIIZ( "ioctl(SIOCGIFHWADDR)",
(Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
- SYSCALL_TRACK( pre_mem_write, tid, "ioctl(SIOCGIFHWADDR)", arg3,
+ PRE_MEM_WRITE( "ioctl(SIOCGIFHWADDR)", arg3,
sizeof(struct vki_ifreq));
break;
case VKI_SIOCGIFMTU: /* get MTU size */
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "ioctl(SIOCGIFMTU)",
+ PRE_MEM_RASCIIZ( "ioctl(SIOCGIFMTU)",
(Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
- SYSCALL_TRACK( pre_mem_write, tid, "ioctl(SIOCGIFMTU)", arg3,
+ PRE_MEM_WRITE( "ioctl(SIOCGIFMTU)", arg3,
sizeof(struct vki_ifreq));
break;
case VKI_SIOCGIFADDR: /* get PA address */
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "ioctl(SIOCGIFADDR)",
+ PRE_MEM_RASCIIZ( "ioctl(SIOCGIFADDR)",
(Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
- SYSCALL_TRACK( pre_mem_write, tid, "ioctl(SIOCGIFADDR)", arg3,
+ PRE_MEM_WRITE( "ioctl(SIOCGIFADDR)", arg3,
sizeof(struct vki_ifreq));
break;
case VKI_SIOCGIFNETMASK: /* get network PA mask */
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "ioctl(SIOCGIFNETMASK)",
+ PRE_MEM_RASCIIZ( "ioctl(SIOCGIFNETMASK)",
(Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
- SYSCALL_TRACK( pre_mem_write, tid, "ioctl(SIOCGIFNETMASK)", arg3,
+ PRE_MEM_WRITE( "ioctl(SIOCGIFNETMASK)", arg3,
sizeof(struct vki_ifreq));
break;
case VKI_SIOCGIFMETRIC: /* get metric */
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "ioctl(SIOCGIFMETRIC)",
+ PRE_MEM_RASCIIZ( "ioctl(SIOCGIFMETRIC)",
(Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
- SYSCALL_TRACK( pre_mem_write, tid, "ioctl(SIOCGIFMETRIC)", arg3,
+ PRE_MEM_WRITE( "ioctl(SIOCGIFMETRIC)", arg3,
sizeof(struct vki_ifreq));
break;
case VKI_SIOCGIFMAP: /* Get device parameters */
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "ioctl(SIOCGIFMAP)",
+ PRE_MEM_RASCIIZ( "ioctl(SIOCGIFMAP)",
(Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
- SYSCALL_TRACK( pre_mem_write, tid, "ioctl(SIOCGIFMAP)", arg3,
+ PRE_MEM_WRITE( "ioctl(SIOCGIFMAP)", arg3,
sizeof(struct vki_ifreq));
break;
case VKI_SIOCGIFTXQLEN: /* Get the tx queue length */
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "ioctl(SIOCGIFTXQLEN)",
+ PRE_MEM_RASCIIZ( "ioctl(SIOCGIFTXQLEN)",
(Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
- SYSCALL_TRACK( pre_mem_write, tid, "ioctl(SIOCGIFTXQLEN)", arg3,
+ PRE_MEM_WRITE( "ioctl(SIOCGIFTXQLEN)", arg3,
sizeof(struct vki_ifreq));
break;
case VKI_SIOCGIFDSTADDR: /* get remote PA address */
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "ioctl(SIOCGIFDSTADDR)",
+ PRE_MEM_RASCIIZ( "ioctl(SIOCGIFDSTADDR)",
(Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
- SYSCALL_TRACK( pre_mem_write, tid, "ioctl(SIOCGIFDSTADDR)", arg3,
+ PRE_MEM_WRITE( "ioctl(SIOCGIFDSTADDR)", arg3,
sizeof(struct vki_ifreq));
break;
case VKI_SIOCGIFBRDADDR: /* get broadcast PA address */
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "ioctl(SIOCGIFBRDADDR)",
+ PRE_MEM_RASCIIZ( "ioctl(SIOCGIFBRDADDR)",
(Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
- SYSCALL_TRACK( pre_mem_write, tid, "ioctl(SIOCGIFBRDADDR)", arg3,
+ PRE_MEM_WRITE( "ioctl(SIOCGIFBRDADDR)", arg3,
sizeof(struct vki_ifreq));
break;
case VKI_SIOCGIFNAME: /* get iface name */
- SYSCALL_TRACK( pre_mem_read, tid, "ioctl(SIOCGIFNAME)",
+ PRE_MEM_READ( "ioctl(SIOCGIFNAME)",
(Addr)((struct vki_ifreq *)arg3)->vki_ifr_ifindex,
sizeof(((struct vki_ifreq *)arg3)->vki_ifr_ifindex) );
- SYSCALL_TRACK( pre_mem_write, tid, "ioctl(SIOCGIFNAME)", arg3,
+ PRE_MEM_WRITE( "ioctl(SIOCGIFNAME)", arg3,
sizeof(struct vki_ifreq));
break;
case VKI_SIOCGMIIPHY: /* get hardware entry */
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "ioctl(SIOCGIFMIIPHY)",
+ PRE_MEM_RASCIIZ( "ioctl(SIOCGIFMIIPHY)",
(Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
- SYSCALL_TRACK( pre_mem_write, tid, "ioctl(SIOCGIFMIIPHY)", arg3,
+ PRE_MEM_WRITE( "ioctl(SIOCGIFMIIPHY)", arg3,
sizeof(struct vki_ifreq));
break;
case VKI_SIOCGMIIREG: /* get hardware entry registers */
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "ioctl(SIOCGIFMIIREG)",
+ PRE_MEM_RASCIIZ( "ioctl(SIOCGIFMIIREG)",
(Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
- SYSCALL_TRACK( pre_mem_read, tid, "ioctl(SIOCGIFMIIREG)",
+ PRE_MEM_READ( "ioctl(SIOCGIFMIIREG)",
(Addr)&((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)arg3)->vki_ifr_data)->phy_id,
sizeof(((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)arg3)->vki_ifr_data)->phy_id) );
- SYSCALL_TRACK( pre_mem_read, tid, "ioctl(SIOCGIFMIIREG)",
+ PRE_MEM_READ( "ioctl(SIOCGIFMIIREG)",
(Addr)&((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)arg3)->vki_ifr_data)->reg_num,
sizeof(((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)arg3)->vki_ifr_data)->reg_num) );
- SYSCALL_TRACK( pre_mem_write, tid, "ioctl(SIOCGIFMIIREG)", arg3,
+ PRE_MEM_WRITE( "ioctl(SIOCGIFMIIREG)", arg3,
sizeof(struct vki_ifreq));
break;
case VKI_SIOCGIFCONF: /* get iface list */
/* WAS:
- SYSCALL_TRACK( pre_mem_write,"ioctl(SIOCGIFCONF)", arg3,
- sizeof(struct ifconf));
+ PRE_MEM_WRITE( "ioctl(SIOCGIFCONF)", arg3, sizeof(struct ifconf));
KERNEL_DO_SYSCALL(tid,res);
if (!VG_(is_kerror)(res) && res == 0)
VG_TRACK( post_mem_write,arg3, sizeof(struct ifconf));
*/
- SYSCALL_TRACK( pre_mem_read,tid, "ioctl(SIOCGIFCONF)", arg3,
- sizeof(struct vki_ifconf));
+ PRE_MEM_READ( "ioctl(SIOCGIFCONF)", arg3, sizeof(struct vki_ifconf));
if ( arg3 ) {
// TODO len must be readable and writable
// buf pointer only needs to be readable
struct vki_ifconf *ifc = (struct vki_ifconf *) arg3;
- SYSCALL_TRACK( pre_mem_write,tid, "ioctl(SIOCGIFCONF).ifc_buf",
+ PRE_MEM_WRITE( "ioctl(SIOCGIFCONF).ifc_buf",
(Addr)(ifc->vki_ifc_buf), ifc->ifc_len );
}
break;
case VKI_SIOCGSTAMP:
- SYSCALL_TRACK( pre_mem_write,tid, "ioctl(SIOCGSTAMP)", arg3,
+ PRE_MEM_WRITE( "ioctl(SIOCGSTAMP)", arg3,
sizeof(struct vki_timeval));
break;
/* SIOCOUTQ is an ioctl that, when called on a socket, returns
@@ -3124,33 +3080,33 @@
It writes this value as an int to the memory location
indicated by the third argument of ioctl(2). */
case VKI_SIOCOUTQ:
- SYSCALL_TRACK( pre_mem_write,tid, "ioctl(SIOCOUTQ)", arg3,
+ PRE_MEM_WRITE( "ioctl(SIOCOUTQ)", arg3,
sizeof(int));
break;
case VKI_SIOCGRARP: /* get RARP table entry */
case VKI_SIOCGARP: /* get ARP table entry */
- SYSCALL_TRACK( pre_mem_write,tid, "ioctl(SIOCGARP)", arg3,
+ PRE_MEM_WRITE( "ioctl(SIOCGARP)", arg3,
sizeof(struct vki_arpreq));
break;
case VKI_SIOCSIFFLAGS: /* set flags */
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "ioctl(SIOCSIFFLAGS)",
+ PRE_MEM_RASCIIZ( "ioctl(SIOCSIFFLAGS)",
(Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
- SYSCALL_TRACK( pre_mem_read, tid, "ioctl(SIOCSIFFLAGS)",
+ PRE_MEM_READ( "ioctl(SIOCSIFFLAGS)",
(Addr)&((struct vki_ifreq *)arg3)->vki_ifr_flags,
sizeof(((struct vki_ifreq *)arg3)->vki_ifr_flags) );
break;
case VKI_SIOCSIFMAP: /* Set device parameters */
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "ioctl(SIOCSIFMAP)",
+ PRE_MEM_RASCIIZ( "ioctl(SIOCSIFMAP)",
(Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
- SYSCALL_TRACK( pre_mem_read, tid, "ioctl(SIOCSIFMAP)",
+ PRE_MEM_READ( "ioctl(SIOCSIFMAP)",
(Addr)&((struct vki_ifreq *)arg3)->ifr_map,
sizeof(((struct vki_ifreq *)arg3)->ifr_map) );
break;
case VKI_SIOCSIFTXQLEN: /* Set the tx queue length */
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "ioctl(SIOCSIFTXQLEN)",
+ PRE_MEM_RASCIIZ( "ioctl(SIOCSIFTXQLEN)",
(Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
- SYSCALL_TRACK( pre_mem_read, tid, "ioctl(SIOCSIFTXQLEN)",
+ PRE_MEM_READ( "ioctl(SIOCSIFTXQLEN)",
(Addr)&((struct vki_ifreq *)arg3)->ifr_qlen,
sizeof(((struct vki_ifreq *)arg3)->ifr_qlen) );
break;
@@ -3158,51 +3114,51 @@
case VKI_SIOCSIFDSTADDR: /* set remote PA address */
case VKI_SIOCSIFBRDADDR: /* set broadcast PA address */
case VKI_SIOCSIFNETMASK: /* set network PA mask */
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "ioctl(SIOCSIF*ADDR)",
+ PRE_MEM_RASCIIZ( "ioctl(SIOCSIF*ADDR)",
(Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
- SYSCALL_TRACK( pre_mem_read, tid, "ioctl(SIOCSIF*ADDR)",
+ PRE_MEM_READ( "ioctl(SIOCSIF*ADDR)",
(Addr)&((struct vki_ifreq *)arg3)->ifr_addr,
sizeof(((struct vki_ifreq *)arg3)->ifr_addr) );
break;
case VKI_SIOCSIFMETRIC: /* set metric */
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "ioctl(SIOCSIFMETRIC)",
+ PRE_MEM_RASCIIZ( "ioctl(SIOCSIFMETRIC)",
(Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
- SYSCALL_TRACK( pre_mem_read, tid, "ioctl(SIOCSIFMETRIC)",
+ PRE_MEM_READ( "ioctl(SIOCSIFMETRIC)",
(Addr)&((struct vki_ifreq *)arg3)->vki_ifr_metric,
sizeof(((struct vki_ifreq *)arg3)->vki_ifr_metric) );
break;
case VKI_SIOCSIFMTU: /* set MTU size */
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "ioctl(SIOCSIFMTU)",
+ PRE_MEM_RASCIIZ( "ioctl(SIOCSIFMTU)",
(Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
- SYSCALL_TRACK( pre_mem_read, tid, "ioctl(SIOCSIFMTU)",
+ PRE_MEM_READ( "ioctl(SIOCSIFMTU)",
(Addr)&((struct vki_ifreq *)arg3)->vki_ifr_mtu,
sizeof(((struct vki_ifreq *)arg3)->vki_ifr_mtu) );
break;
case VKI_SIOCSIFHWADDR: /* set hardware address */
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "ioctl(SIOCSIFHWADDR)",
+ PRE_MEM_RASCIIZ( "ioctl(SIOCSIFHWADDR)",
(Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
- SYSCALL_TRACK( pre_mem_read, tid, "ioctl(SIOCSIFHWADDR)",
+ PRE_MEM_READ( "ioctl(SIOCSIFHWADDR)",
(Addr)&((struct vki_ifreq *)arg3)->ifr_hwaddr,
sizeof(((struct vki_ifreq *)arg3)->ifr_hwaddr) );
break;
case VKI_SIOCSMIIREG: /* set hardware entry registers */
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "ioctl(SIOCSMIIREG)",
+ PRE_MEM_RASCIIZ( "ioctl(SIOCSMIIREG)",
(Addr)((struct vki_ifreq *)arg3)->vki_ifr_name );
- SYSCALL_TRACK( pre_mem_read, tid, "ioctl(SIOCSMIIREG)",
+ PRE_MEM_READ( "ioctl(SIOCSMIIREG)",
(Addr)&((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)arg3)->vki_ifr_data)->phy_id,
sizeof(((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)arg3)->vki_ifr_data)->phy_id) );
- SYSCALL_TRACK( pre_mem_read, tid, "ioctl(SIOCSMIIREG)",
+ PRE_MEM_READ( "ioctl(SIOCSMIIREG)",
(Addr)&((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)arg3)->vki_ifr_data)->reg_num,
sizeof(((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)arg3)->vki_ifr_data)->reg_num) );
- SYSCALL_TRACK( pre_mem_read, tid, "ioctl(SIOCSMIIREG)",
+ PRE_MEM_READ( "ioctl(SIOCSMIIREG)",
(Addr)&((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)arg3)->vki_ifr_data)->val_in,
sizeof(((struct vki_mii_ioctl_data *)&((struct vki_ifreq *)arg3)->vki_ifr_data)->val_in) );
break;
/* Routing table calls. */
case VKI_SIOCADDRT: /* add routing table entry */
case VKI_SIOCDELRT: /* delete routing table entry */
- SYSCALL_TRACK( pre_mem_read,tid,"ioctl(SIOCADDRT/DELRT)", arg3,
- sizeof(struct vki_rtentry));
+ PRE_MEM_READ( "ioctl(SIOCADDRT/DELRT)", arg3,
+ sizeof(struct vki_rtentry));
break;
/* RARP cache control calls. */
@@ -3211,17 +3167,14 @@
/* ARP cache control calls. */
case VKI_SIOCSARP: /* set ARP table entry */
case VKI_SIOCDARP: /* delete ARP table entry */
- SYSCALL_TRACK( pre_mem_read,tid, "ioctl(SIOCSIFFLAGS)", arg3,
- sizeof(struct vki_ifreq));
+ PRE_MEM_READ( "ioctl(SIOCSIFFLAGS)", arg3, sizeof(struct vki_ifreq));
break;
case VKI_SIOCGPGRP:
- SYSCALL_TRACK( pre_mem_write, tid, "ioctl(SIOCGPGRP)", arg3,
- sizeof(int) );
+ PRE_MEM_WRITE( "ioctl(SIOCGPGRP)", arg3, sizeof(int) );
break;
case VKI_SIOCSPGRP:
- SYSCALL_TRACK( pre_mem_read, tid, "ioctl(SIOCSPGRP)", arg3,
- sizeof(int) );
+ PRE_MEM_READ( "ioctl(SIOCSPGRP)", arg3, sizeof(int) );
tst->sys_flags &= ~MayBlock;
break;
@@ -3246,10 +3199,8 @@
case VKI_SOUND_PCM_READ_BITS:
case (VKI_SOUND_PCM_READ_BITS|0x40000000): /* what the fuck ? */
case VKI_SOUND_PCM_READ_FILTER:
- SYSCALL_TRACK( pre_mem_write,tid,
- "ioctl(SNDCTL_XXX|SOUND_XXX (SIOR, int))",
- arg3,
- sizeof(int));
+ PRE_MEM_WRITE( "ioctl(SNDCTL_XXX|SOUND_XXX (SIOR, int))",
+ arg3, sizeof(int));
break;
case VKI_SNDCTL_SEQ_CTRLRATE:
case VKI_SNDCTL_DSP_SPEED:
@@ -3270,23 +3221,18 @@
case VKI_SNDCTL_TMR_SOURCE:
case VKI_SNDCTL_MIDI_PRETIME:
case VKI_SNDCTL_MIDI_MPUMODE:
- SYSCALL_TRACK( pre_mem_read,tid, "ioctl(SNDCTL_XXX|SOUND_XXX "
- "(SIOWR, int))",
+ PRE_MEM_READ( "ioctl(SNDCTL_XXX|SOUND_XXX (SIOWR, int))",
arg3, sizeof(int));
- SYSCALL_TRACK( pre_mem_write,tid, "ioctl(SNDCTL_XXX|SOUND_XXX "
- "(SIOWR, int))",
+ PRE_MEM_WRITE( "ioctl(SNDCTL_XXX|SOUND_XXX (SIOWR, int))",
arg3, sizeof(int));
break;
case VKI_SNDCTL_DSP_GETOSPACE:
case VKI_SNDCTL_DSP_GETISPACE:
- SYSCALL_TRACK( pre_mem_write,tid,
- "ioctl(SNDCTL_XXX|SOUND_XXX "
- "(SIOR, audio_buf_info))", arg3,
- sizeof(vki_audio_buf_info));
+ PRE_MEM_WRITE( "ioctl(SNDCTL_XXX|SOUND_XXX (SIOR, audio_buf_info))",
+ arg3, sizeof(vki_audio_buf_info));
break;
case VKI_SNDCTL_DSP_SETTRIGGER:
- SYSCALL_TRACK( pre_mem_read,tid,
- "ioctl(SNDCTL_XXX|SOUND_XXX (SIOW, int))",
+ PRE_MEM_READ( "ioctl(SNDCTL_XXX|SOUND_XXX (SIOW, int))",
arg3, sizeof(int));
break;
@@ -3308,91 +3254,91 @@
break;
case VKI_RTC_RD_TIME:
case VKI_RTC_ALM_READ:
- SYSCALL_TRACK( pre_mem_write,tid, "ioctl(RTC_RD_TIME/ALM_READ)",
+ PRE_MEM_WRITE( "ioctl(RTC_RD_TIME/ALM_READ)",
arg3, sizeof(struct vki_rtc_time));
break;
case VKI_RTC_ALM_SET:
- SYSCALL_TRACK( pre_mem_read,tid, "ioctl(RTC_ALM_SET)", arg3,
+ PRE_MEM_READ( "ioctl(RTC_ALM_SET)", arg3,
sizeof(struct vki_rtc_time));
break;
case VKI_RTC_IRQP_READ:
- SYSCALL_TRACK( pre_mem_write,tid, "ioctl(RTC_IRQP_READ)", arg3,
+ PRE_MEM_WRITE( "ioctl(RTC_IRQP_READ)", arg3,
sizeof(unsigned long));
break;
# ifdef BLKGETSIZE
case BLKGETSIZE:
- SYSCALL_TRACK( pre_mem_write,tid, "ioctl(BLKGETSIZE)", arg3,
+ PRE_MEM_WRITE( "ioctl(BLKGETSIZE)", arg3,
sizeof(unsigned long));
break;
# endif /* BLKGETSIZE */
/* Hard disks */
case VKI_HDIO_GET_IDENTITY: /* 0x030d */
- SYSCALL_TRACK( pre_mem_write,tid, "ioctl(HDIO_GET_IDENTITY)", arg3,
+ PRE_MEM_WRITE( "ioctl(HDIO_GET_IDENTITY)", arg3,
VKI_SIZEOF_STRUCT_HD_DRIVEID );
break;
/* CD ROM stuff (??) */
case VKI_CDROM_GET_MCN:
- SYSCALL_TRACK( pre_mem_read,tid, "ioctl(CDROM_GET_MCN)", arg3,
+ PRE_MEM_READ( "ioctl(CDROM_GET_MCN)", arg3,
sizeof(struct vki_cdrom_mcn) );
break;
case VKI_CDROM_SEND_PACKET:
- SYSCALL_TRACK( pre_mem_read,tid, "ioctl(CDROM_SEND_PACKET)", arg3,
+ PRE_MEM_READ( "ioctl(CDROM_SEND_PACKET)", arg3,
sizeof(struct vki_cdrom_generic_command));
break;
case VKI_CDROMSUBCHNL:
- SYSCALL_TRACK( pre_mem_read,tid,
+ PRE_MEM_READ(
"ioctl(CDROMSUBCHNL (cdsc_format, char))",
(Addr) &(((struct vki_cdrom_subchnl*) arg3)->cdsc_format),
sizeof(((struct vki_cdrom_subchnl*) arg3)->cdsc_format));
- SYSCALL_TRACK( pre_mem_write,tid,
+ PRE_MEM_WRITE(
"ioctl(CDROMSUBCHNL)", arg3,
sizeof(struct vki_cdrom_subchnl));
break;
case VKI_CDROMREADMODE2:
- SYSCALL_TRACK( pre_mem_read,tid, "ioctl(CDROMREADMODE2)", arg3,
+ PRE_MEM_READ( "ioctl(CDROMREADMODE2)", arg3,
VKI_CD_FRAMESIZE_RAW0 );
break;
case VKI_CDROMREADTOCHDR:
- SYSCALL_TRACK( pre_mem_write,tid,
+ PRE_MEM_WRITE(
"ioctl(CDROMREADTOCHDR)", arg3,
sizeof(struct vki_cdrom_tochdr));
break;
case VKI_CDROMREADTOCENTRY:
- SYSCALL_TRACK( pre_mem_read,tid,
+ PRE_MEM_READ(
"ioctl(CDROMREADTOCENTRY (cdte_format, char))",
(Addr) &(((struct vki_cdrom_tocentry*) arg3)->cdte_format),
sizeof(((struct vki_cdrom_tocentry*) arg3)->cdte_format));
- SYSCALL_TRACK( pre_mem_read,tid,
+ PRE_MEM_READ(
"ioctl(CDROMREADTOCENTRY (cdte_track, char))",
(Addr) &(((struct vki_cdrom_tocentry*) arg3)->cdte_track),
sizeof(((struct vki_cdrom_tocentry*) arg3)->cdte_track));
- SYSCALL_TRACK( pre_mem_write,tid,
+ PRE_MEM_WRITE(
"ioctl(CDROMREADTOCENTRY)", arg3,
sizeof(struct vki_cdrom_tocentry));
break;
case VKI_CDROMMULTISESSION: /* 0x5310 */
- SYSCALL_TRACK( pre_mem_write,tid, "ioctl(CDROMMULTISESSION)", arg3,
+ PRE_MEM_WRITE( "ioctl(CDROMMULTISESSION)", arg3,
sizeof(struct vki_cdrom_multisession));
break;
case VKI_CDROMVOLREAD: /* 0x5313 */
- SYSCALL_TRACK( pre_mem_write,tid, "ioctl(CDROMVOLREAD)", arg3,
+ PRE_MEM_WRITE( "ioctl(CDROMVOLREAD)", arg3,
sizeof(struct vki_cdrom_volctrl));
break;
case VKI_CDROMREADAUDIO: /* 0x530e */
- SYSCALL_TRACK( pre_mem_read,tid, "ioctl(CDROMREADAUDIO)", arg3,
+ PRE_MEM_READ( "ioctl(CDROMREADAUDIO)", arg3,
sizeof (struct vki_cdrom_read_audio));
if ( arg3 ) {
/* ToDo: don't do any of the following if the structure is invalid */
struct vki_cdrom_read_audio *cra = (struct vki_cdrom_read_audio *) arg3;
- SYSCALL_TRACK( pre_mem_write, tid, "ioctl(CDROMREADAUDIO).buf",
- (Addr)cra->buf, cra->nframes * VKI_CD_FRAMESIZE_RAW);
+ PRE_MEM_WRITE( "ioctl(CDROMREADAUDIO).buf",
+ (Addr)(cra->buf), cra->nframes * VKI_CD_FRAMESIZE_RAW);
}
break;
case VKI_CDROMPLAYMSF:
- SYSCALL_TRACK( pre_mem_read,tid, "ioctl(CDROMPLAYMSF)", arg3,
+ PRE_MEM_READ( "ioctl(CDROMPLAYMSF)", arg3,
sizeof(struct vki_cdrom_msf));
break;
/* The following two are probably bogus (should check args
@@ -3402,22 +3348,20 @@
break;
case VKI_FIGETBSZ:
- SYSCALL_TRACK( pre_mem_write,tid, "ioctl(FIGETBSZ)", arg3,
+ PRE_MEM_WRITE( "ioctl(FIGETBSZ)", arg3,
sizeof(unsigned long));
break;
case VKI_FIBMAP:
- SYSCALL_TRACK( pre_mem_read,tid, "ioctl(FIBMAP)", arg3,
+ PRE_MEM_READ( "ioctl(FIBMAP)", arg3,
sizeof(unsigned long));
break;
case VKI_FBIOGET_VSCREENINFO: /* 0x4600 */
- SYSCALL_TRACK( pre_mem_write,tid,
- "ioctl(FBIOGET_VSCREENINFO)", arg3,
+ PRE_MEM_WRITE( "ioctl(FBIOGET_VSCREENINFO)", arg3,
sizeof(struct vki_fb_var_screeninfo));
break;
case VKI_FBIOGET_FSCREENINFO: /* 0x4602 */
- SYSCALL_TRACK( pre_mem_write,tid,
- "ioctl(FBIOGET_FSCREENINFO)", arg3,
+ PRE_MEM_WRITE( "ioctl(FBIOGET_FSCREENINFO)", arg3,
sizeof(struct vki_fb_fix_screeninfo));
break;
@@ -3427,80 +3371,61 @@
case VKI_PPRELEASE:
break;
case VKI_PPSETMODE:
- SYSCALL_TRACK( pre_mem_read, tid, "ioctl(PPSETMODE)", arg3,
- sizeof(int) );
+ PRE_MEM_READ( "ioctl(PPSETMODE)", arg3, sizeof(int) );
break;
case VKI_PPGETMODE:
- SYSCALL_TRACK( pre_mem_write, tid, "ioctl(PPGETMODE)", arg3,
- sizeof(int) );
+ PRE_MEM_WRITE( "ioctl(PPGETMODE)", arg3, sizeof(int) );
break;
case VKI_PPSETPHASE:
- SYSCALL_TRACK( pre_mem_read, tid, "ioctl(PPSETPHASE)", arg3,
- sizeof(int) );
+ PRE_MEM_READ( "ioctl(PPSETPHASE)", arg3, sizeof(int) );
break;
case VKI_PPGETPHASE:
- SYSCALL_TRACK( pre_mem_write, tid, "ioctl(PPGETPHASE)", arg3,
- sizeof(int) );
+ PRE_MEM_WRITE( "ioctl(PPGETPHASE)", arg3, sizeof(int) );
break;
case VKI_PPGETMODES:
- SYSCALL_TRACK( pre_mem_write, tid, "ioctl(PPGETMODES)", arg3,
- sizeof(unsigned int) );
+ PRE_MEM_WRITE( "ioctl(PPGETMODES)", arg3, sizeof(unsigned int) );
break;
case VKI_PPSETFLAGS:
- SYSCALL_TRACK( pre_mem_read, tid, "ioctl(PPSETFLAGS)", arg3,
- sizeof(int) );
+ PRE_MEM_READ( "ioctl(PPSETFLAGS)", arg3, sizeof(int) );
break;
case VKI_PPGETFLAGS:
- SYSCALL_TRACK( pre_mem_write, tid, "ioctl(PPGETFLAGS)", arg3,
- sizeof(int) );
+ PRE_MEM_WRITE( "ioctl(PPGETFLAGS)", arg3, sizeof(int) );
break;
case VKI_PPRSTATUS:
- SYSCALL_TRACK( pre_mem_write, tid, "ioctl(PPRSTATUS)", arg3,
- sizeof(unsigned char) );
+ PRE_MEM_WRITE( "ioctl(PPRSTATUS)", arg3, sizeof(unsigned char) );
break;
case VKI_PPRDATA:
- SYSCALL_TRACK( pre_mem_write, tid, "ioctl(PPRDATA)", arg3,
- sizeof(unsigned char) );
+ PRE_MEM_WRITE( "ioctl(PPRDATA)", arg3, sizeof(unsigned char) );
break;
case VKI_PPRCONTROL:
- SYSCALL_TRACK( pre_mem_write, tid, "ioctl(PPRCONTROL)", arg3,
- sizeof(unsigned char) );
+ PRE_MEM_WRITE( "ioctl(PPRCONTROL)", arg3, sizeof(unsigned char) );
break;
case VKI_PPWDATA:
- SYSCALL_TRACK( pre_mem_read, tid, "ioctl(PPWDATA)", arg3,
- sizeof(unsigned char) );
+ PRE_MEM_READ( "ioctl(PPWDATA)", arg3, sizeof(unsigned char) );
break;
case VKI_PPWCONTROL:
- SYSCALL_TRACK( pre_mem_read, tid, "ioctl(PPWCONTROL)", arg3,
- sizeof(unsigned char) );
+ PRE_MEM_READ( "ioctl(PPWCONTROL)", arg3, sizeof(unsigned char) );
break;
case VKI_PPFCONTROL:
- SYSCALL_TRACK( pre_mem_read, tid, "ioctl(PPFCONTROL)", arg3,
- 2 * sizeof(unsigned char) );
+ PRE_MEM_READ( "ioctl(PPFCONTROL)", arg3, 2 * sizeof(unsigned char) );
break;
case VKI_PPDATADIR:
- SYSCALL_TRACK( pre_mem_read, tid, "ioctl(PPDATADIR)", arg3,
- sizeof(int) );
+ PRE_MEM_READ( "ioctl(PPDATADIR)", arg3, sizeof(int) );
break;
case VKI_PPNEGOT:
- SYSCALL_TRACK( pre_mem_read, tid, "ioctl(PPNEGOT)", arg3,
- sizeof(int) );
+ PRE_MEM_READ( "ioctl(PPNEGOT)", arg3, sizeof(int) );
break;
case VKI_PPWCTLONIRQ:
- SYSCALL_TRACK( pre_mem_read, tid, "ioctl(PPWCTLONIRQ)", arg3,
- sizeof(unsigned char) );
+ PRE_MEM_READ( "ioctl(PPWCTLONIRQ)", arg3, sizeof(unsigned char) );
break;
case VKI_PPCLRIRQ:
- SYSCALL_TRACK( pre_mem_write, tid, "ioctl(PPCLRIRQ)", arg3,
- sizeof(int) );
+ PRE_MEM_WRITE( "ioctl(PPCLRIRQ)", arg3, sizeof(int) );
break;
case VKI_PPSETTIME:
- SYSCALL_TRACK( pre_mem_read, tid, "ioctl(PPSETTIME)", arg3,
- sizeof(struct vki_timeval) );
+ PRE_MEM_READ( "ioctl(PPSETTIME)", arg3, sizeof(struct vki_timeval) );
break;
case VKI_PPGETTIME:
- SYSCALL_TRACK( pre_mem_write, tid, "ioctl(PPGETTIME)", arg3,
- sizeof(struct vki_timeval) );
+ PRE_MEM_WRITE( "ioctl(PPGETTIME)", arg3, sizeof(struct vki_timeval) );
break;
/* We don't have any specific information on it, so
@@ -3540,11 +3465,9 @@
}
} else {
if ((dir & _VKI_IOC_WRITE) && size > 0)
- SYSCALL_TRACK( pre_mem_read,tid, "ioctl(generic)",
- arg3, size);
+ PRE_MEM_READ( "ioctl(generic)", arg3, size);
if ((dir & _VKI_IOC_READ) && size > 0)
- SYSCALL_TRACK( pre_mem_write,tid, "ioctl(generic)",
- arg3, size);
+ PRE_MEM_WRITE( "ioctl(generic)", arg3, size);
}
break;
}
@@ -3563,21 +3486,21 @@
"is an IOCTL, request = 0x%x, d = %d, argp = 0x%x",
arg2,arg1,arg3);
*/
- MAYBE_PRINTF("ioctl ( %d, 0x%x, %p )\n",arg1,arg2,arg3);
+ PRINT("ioctl ( %d, 0x%x, %p )",arg1,arg2,arg3);
switch (arg2 /* request */) {
case VKI_TCSETS:
case VKI_TCSETSW:
case VKI_TCSETSF:
break;
case VKI_TCGETS:
- VG_TRACK( post_mem_write, arg3, sizeof(struct vki_termios) );
+ POST_MEM_WRITE( arg3, sizeof(struct vki_termios) );
break;
case VKI_TCSETA:
case VKI_TCSETAW:
case VKI_TCSETAF:
break;
case VKI_TCGETA:
- VG_TRACK( post_mem_write, arg3, sizeof(struct vki_termio) );
+ POST_MEM_WRITE( arg3, sizeof(struct vki_termio) );
break;
case VKI_TCSBRK:
case VKI_TCXONC:
@@ -3585,7 +3508,7 @@
case VKI_TCFLSH:
break;
case VKI_TIOCGWINSZ:
- VG_TRACK( post_mem_write, arg3, sizeof(struct vki_winsize) );
+ POST_MEM_WRITE( arg3, sizeof(struct vki_winsize) );
break;
case VKI_TIOCSWINSZ:
case VKI_TIOCMBIS:
@@ -3593,18 +3516,18 @@
case VKI_TIOCMSET:
break;
case VKI_TIOCLINUX:
- VG_TRACK( post_mem_write, arg3, sizeof(char *) );
+ POST_MEM_WRITE( arg3, sizeof(char *) );
break;
case VKI_TIOCGPGRP:
/* Get process group ID for foreground processing group. */
- VG_TRACK( post_mem_write, arg3, sizeof(vki_pid_t) );
+ POST_MEM_WRITE( arg3, sizeof(vki_pid_t) );
break;
case VKI_TIOCSPGRP:
/* Set a process group ID? */
- VG_TRACK( post_mem_write, arg3, sizeof(vki_pid_t) );
+ POST_MEM_WRITE( arg3, sizeof(vki_pid_t) );
break;
case VKI_TIOCGPTN: /* Get Pty Number (of pty-mux device) */
- VG_TRACK( post_mem_write, arg3, sizeof(int));
+ POST_MEM_WRITE( arg3, sizeof(int));
break;
case VKI_TIOCSCTTY:
break;
@@ -3615,7 +3538,7 @@
case VKI_FIOASYNC:
break;
case VKI_FIONREAD: /* identical to SIOCINQ */
- VG_TRACK( post_mem_write, arg3, sizeof(int) );
+ POST_MEM_WRITE( arg3, sizeof(int) );
break;
case VKI_SG_SET_COMMAND_Q:
@@ -3651,11 +3574,10 @@
# ifndef ISDN_MAX_CHANNELS
# define ISDN_MAX_CHANNELS 64
# endif
- VG_TRACK( post_mem_write, arg3,
- ISDN_MAX_CHANNELS * 2 * sizeof(unsigned long) );
+ POST_MEM_WRITE( arg3, ISDN_MAX_CHANNELS * 2 * sizeof(unsigned long) );
break;
case VKI_IIOCNETGPN:
- VG_TRACK( post_mem_write, arg3, sizeof(vki_isdn_net_ioctl_phone) );
+ POST_MEM_WRITE( arg3, sizeof(vki_isdn_net_ioctl_phone) );
break;
/* These all use struct ifreq AFAIK */
@@ -3720,8 +3642,7 @@
break;
case VKI_SIOCGIFCONF: /* get iface list */
/* WAS:
- SYSCALL_TRACK( pre_mem_write,"ioctl(SIOCGIFCONF)", arg3,
- sizeof(struct ifconf));
+ PRE_MEM_WRITE("ioctl(SIOCGIFCONF)", arg3, sizeof(struct ifconf));
KERNEL_DO_SYSCALL(tid,res);
if (!VG_(is_kerror)(res) && res == 0)
VG_TRACK( post_mem_write,arg3, sizeof(struct ifconf));
@@ -3729,7 +3650,7 @@
if (res == 0 && arg3 ) {
struct vki_ifconf *ifc = (struct vki_ifconf *) arg3;
if (ifc->vki_ifc_buf != NULL)
- VG_TRACK( post_mem_write, (Addr)(ifc->vki_ifc_buf), ifc->ifc_len );
+ POST_MEM_WRITE( (Addr)(ifc->vki_ifc_buf), ifc->ifc_len );
}
break;
case VKI_SIOCGSTAMP:
@@ -3882,8 +3803,7 @@
case VKI_CDROMREADAUDIO:
{
struct vki_cdrom_read_audio *cra = (struct vki_cdrom_read_audio *) arg3;
- VG_TRACK( post_mem_write, (Addr)(cra->buf),
- cra->nframes * VKI_CD_FRAMESIZE_RAW);
+ POST_MEM_WRITE( (Addr)(cra->buf), cra->nframes * VKI_CD_FRAMESIZE_RAW);
break;
}
@@ -3925,31 +3845,31 @@
case VKI_PPSETTIME:
break;
case VKI_PPGETMODE:
- VG_TRACK( post_mem_write, arg3, sizeof(int) );
+ POST_MEM_WRITE( arg3, sizeof(int) );
break;
case VKI_PPGETPHASE:
- VG_TRACK( post_mem_write, arg3, sizeof(int) );
+ POST_MEM_WRITE( arg3, sizeof(int) );
break;
case VKI_PPGETMODES:
- VG_TRACK( post_mem_write, arg3, sizeof(unsigned int) );
+ POST_MEM_WRITE( arg3, sizeof(unsigned int) );
break;
case VKI_PPGETFLAGS:
- VG_TRACK( post_mem_write, arg3, sizeof(int) );
+ POST_MEM_WRITE( arg3, sizeof(int) );
break;
case VKI_PPRSTATUS:
- VG_TRACK( post_mem_write, arg3, sizeof(unsigned char) );
+ POST_MEM_WRITE( arg3, sizeof(unsigned char) );
break;
case VKI_PPRDATA:
- VG_TRACK( post_mem_write, arg3, sizeof(unsigned char) );
+ POST_MEM_WRITE( arg3, sizeof(unsigned char) );
break;
case VKI_PPRCONTROL:
- VG_TRACK( post_mem_write, arg3, sizeof(unsigned char) );
+ POST_MEM_WRITE( arg3, sizeof(unsigned char) );
break;
case VKI_PPCLRIRQ:
- VG_TRACK( post_mem_write, arg3, sizeof(int) );
+ POST_MEM_WRITE( arg3, sizeof(int) );
break;
case VKI_PPGETTIME:
- VG_TRACK( post_mem_write, arg3, sizeof(struct vki_timeval) );
+ POST_MEM_WRITE( arg3, sizeof(struct vki_timeval) );
break;
/* We don't have any specific information on it, so
@@ -3975,7 +3895,7 @@
PRE(kill)
{
/* int kill(pid_t pid, int sig); */
- MAYBE_PRINTF("kill ( %d, %d )\n", arg1,arg2);
+ PRINT("kill ( %d, %d )", arg1,arg2);
if (arg2 == VKI_SIGVGINT || arg2 == VKI_SIGVGKILL)
set_result( -VKI_EINVAL );
}
@@ -4002,15 +3922,15 @@
PRE(link)
{
/* int link(const char *oldpath, const char *newpath); */
- MAYBE_PRINTF("link ( %p, %p)\n", arg1, arg2);
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "link(oldpath)", arg1);
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "link(newpath)", arg2);
+ PRINT("link ( %p, %p)", arg1, arg2);
+ PRE_MEM_RASCIIZ( "link(oldpath)", arg1);
+ PRE_MEM_RASCIIZ( "link(newpath)", arg2);
}
PRE(lseek)
{
/* off_t lseek(int fildes, off_t offset, int whence); */
- MAYBE_PRINTF("lseek ( %d, %lld, %d )\n",arg1,(ULong)arg2,arg3);
+ PRINT("lseek ( %d, %d, %d )",arg1,arg2,arg3);
}
PRE(_llseek)
@@ -4018,55 +3938,51 @@
/* int _llseek(unsigned int fd, unsigned long offset_high,
unsigned long offset_low,
loff_t * result, unsigned int whence); */
- MAYBE_PRINTF("llseek ( %d, 0x%x, 0x%x, %p, %d )\n",
- arg1,arg2,arg3,arg4,arg5);
- SYSCALL_TRACK( pre_mem_write, tid, "llseek(result)", arg4,
- sizeof(vki_loff_t));
+ PRINT("llseek ( %d, 0x%x, 0x%x, %p, %d )", arg1,arg2,arg3,arg4,arg5);
+ PRE_MEM_WRITE( "llseek(result)", arg4, sizeof(vki_loff_t));
}
POST(_llseek)
{
if (res == 0)
- VG_TRACK( post_mem_write, arg4, sizeof(vki_loff_t) );
+ POST_MEM_WRITE( arg4, sizeof(vki_loff_t) );
}
PRE(lstat)
{
/* int lstat(const char *file_name, struct stat *buf); */
- MAYBE_PRINTF("lstat ( %p(%s), %p )\n",arg1,arg1,arg2);
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "lstat(file_name)", arg1 );
- SYSCALL_TRACK( pre_mem_write, tid, "lstat(buf)", arg2,
- sizeof(struct vki_stat) );
+ PRINT("lstat ( %p(%s), %p )",arg1,arg1,arg2);
+ PRE_MEM_RASCIIZ( "lstat(file_name)", arg1 );
+ PRE_MEM_WRITE( "lstat(buf)", arg2, sizeof(struct vki_stat) );
}
POST(lstat)
{
if (res == 0) {
- VG_TRACK( post_mem_write, arg2, sizeof(struct vki_stat) );
+ POST_MEM_WRITE( arg2, sizeof(struct vki_stat) );
}
}
PRE(lstat64)
{
/* int lstat64(const char *file_name, struct stat64 *buf); */
- MAYBE_PRINTF("lstat64 ( %p(%s), %p )\n",arg1,arg1,arg2);
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "lstat64(file_name)", arg1 );
- SYSCALL_TRACK( pre_mem_write, tid, "lstat64(buf)", arg2,
- sizeof(struct vki_stat64) );
+ PRINT("lstat64 ( %p(%s), %p )",arg1,arg1,arg2);
+ PRE_MEM_RASCIIZ( "lstat64(file_name)", arg1 );
+ PRE_MEM_WRITE( "lstat64(buf)", arg2, sizeof(struct vki_stat64) );
}
POST(lstat64)
{
if (res == 0) {
- VG_TRACK( post_mem_write, arg2, sizeof(struct vki_stat64) );
+ POST_MEM_WRITE( arg2, sizeof(struct vki_stat64) );
}
}
PRE(mkdir)
{
/* int mkdir(const char *pathname, mode_t mode); */
- MAYBE_PRINTF("mkdir ( %p, %d )\n", arg1,arg2);
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "mkdir(pathname)", arg1 );
+ PRINT("mkdir ( %p, %d )", arg1,arg2);
+ PRE_MEM_RASCIIZ( "mkdir(pathname)", arg1 );
}
PRE(mmap2)
@@ -4078,7 +3994,7 @@
/* void* mmap2(void *start, size_t length, int prot,
int flags, int fd, off_t offset);
*/
- MAYBE_PRINTF("mmap2 ( %p, %llu, %d, %d, %d, %d )\n",
+ PRINT("mmap2 ( %p, %llu, %d, %d, %d, %d )",
arg1, (ULong)arg2, arg3, arg4, arg5, arg6 );
if (arg4 & VKI_MAP_FIXED) {
@@ -4110,12 +4026,12 @@
vg_assert(tid = tst->tid);
PLATFORM_GET_MMAP_ARGS(tst, a1, a2, a3, a4, a5, a6);
- MAYBE_PRINTF("mmap ( %p, %llu, %d, %d, %d, %d )\n",
+ PRINT("mmap ( %p, %llu, %d, %d, %d, %d )",
a1, (ULong)a2, a3, a4, a5, a6 );
if (a4 & VKI_MAP_FIXED) {
if (!valid_client_addr(a1, a2, tid, "mmap")) {
- MAYBE_PRINTF("mmap failing: %p-%p\n", a1, a1+a2);
+ PRINT("mmap failing: %p-%p\n", a1, a1+a2);
set_result( -VKI_ENOMEM );
}
} else {
@@ -4140,7 +4056,7 @@
{
/* int mprotect(const void *addr, size_t len, int prot); */
/* should addr .. addr+len-1 be checked before the call? */
- MAYBE_PRINTF("mprotect ( %p, %llu, %d )\n", arg1,(ULong)arg2,arg3);
+ PRINT("mprotect ( %p, %llu, %d )", arg1,(ULong)arg2,arg3);
if (!valid_client_addr(arg1, arg2, tid, "mprotect"))
set_result( -VKI_ENOMEM );
@@ -4164,7 +4080,7 @@
{
/* int munmap(void *start, size_t length); */
/* should start .. start+length-1 be checked before the call? */
- MAYBE_PRINTF("munmap ( %p, %llu )\n", arg1,(ULong)arg2);
+ PRINT("munmap ( %p, %llu )", arg1,(ULong)arg2);
if (!valid_client_addr(arg1, arg2, tid, "munmap"))
set_result( -VKI_EINVAL );
@@ -4183,31 +4099,28 @@
PRE(mincore)
{
/* int mincore(void *start, size_t length, unsigned char *vec); */
- MAYBE_PRINTF("mincore ( %p, %llu, %p )\n", arg1,(ULong)arg2,arg3);
- SYSCALL_TRACK(pre_mem_write, tid, "mincore(vec)",
- arg3, (arg2 + 4096 - 1) / 4096);
+ PRINT("mincore ( %p, %llu, %p )", arg1,(ULong)arg2,arg3);
+ PRE_MEM_WRITE( "mincore(vec)", arg3, (arg2 + 4096 - 1) / 4096);
}
POST(mincore)
{
- VG_TRACK( post_mem_write, arg3, (arg2 + 4096 - 1) / 4096 );
+ POST_MEM_WRITE( arg3, (arg2 + 4096 - 1) / 4096 );
}
PRE(nanosleep)
{
/* int nanosleep(const struct timespec *req, struct timespec *rem); */
- MAYBE_PRINTF("nanosleep ( %p, %p )\n", arg1,arg2);
- SYSCALL_TRACK( pre_mem_read, tid, "nanosleep(req)", arg1,
- sizeof(struct vki_timespec) );
+ PRINT("nanosleep ( %p, %p )", arg1,arg2);
+ PRE_MEM_READ( "nanosleep(req)", arg1, sizeof(struct vki_timespec) );
if (arg2 != (UWord)NULL)
- SYSCALL_TRACK( pre_mem_write, tid, "nanosleep(rem)", arg2,
- sizeof(struct vki_timespec) );
+ PRE_MEM_WRITE( "nanosleep(rem)", arg2, sizeof(struct vki_timespec) );
}
POST(nanosleep)
{
if (arg2 != (UWord)NULL && res == -VKI_EINTR)
- VG_TRACK( post_mem_write, arg2, sizeof(struct vki_timespec) );
+ POST_MEM_WRITE( arg2, sizeof(struct vki_timespec) );
}
PRE(_newselect)
@@ -4216,20 +4129,18 @@
fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
struct timeval *timeout);
*/
- MAYBE_PRINTF("newselect ( %d, %p, %p, %p, %p )\n",
- arg1,arg2,arg3,arg4,arg5);
+ PRINT("newselect ( %d, %p, %p, %p, %p )", arg1,arg2,arg3,arg4,arg5);
if (arg2 != 0)
- SYSCALL_TRACK( pre_mem_read, tid, "newselect(readfds)",
+ PRE_MEM_READ( "newselect(readfds)",
arg2, arg1/8 /* __FD_SETSIZE/8 */ );
if (arg3 != 0)
- SYSCALL_TRACK( pre_mem_read, tid, "newselect(writefds)",
+ PRE_MEM_READ( "newselect(writefds)",
arg3, arg1/8 /* __FD_SETSIZE/8 */ );
if (arg4 != 0)
- SYSCALL_TRACK( pre_mem_read, tid, "newselect(exceptfds)",
+ PRE_MEM_READ( "newselect(exceptfds)",
arg4, arg1/8 /* __FD_SETSIZE/8 */ );
if (arg5 != 0)
- SYSCALL_TRACK( pre_mem_read, tid, "newselect(timeout)", arg5,
- sizeof(struct vki_timeval) );
+ PRE_MEM_READ( "newselect(timeout)", arg5, sizeof(struct vki_timeval) );
}
PRE(open)
@@ -4237,12 +4148,12 @@
/* int open(const char *pathname, int flags, mode_t mode); */
if (arg2 & VKI_O_CREAT) {
/* int open(const char *pathname, int flags, mode_t mode); */
- MAYBE_PRINTF("open ( %p(%s), %d, %d ) --> ",arg1,arg1,arg2,arg3);
+ PRINT("open ( %p(%s), %d, %d )",arg1,arg1,arg2,arg3);
} else {
/* int open(const char *pathname, int flags); */
- MAYBE_PRINTF("open ( %p(%s), %d ) --> ",arg1,arg1,arg2);
+ PRINT("open ( %p(%s), %d )",arg1,arg1,arg2);
}
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "open(pathname)", arg1 );
+ PRE_MEM_RASCIIZ( "open(pathname)", arg1 );
}
POST(open)
@@ -4254,40 +4165,39 @@
if (VG_(clo_track_fds))
record_fd_open(tid, res, VG_(arena_strdup)(VG_AR_CORE, (Char*)arg1));
}
- MAYBE_PRINTF("%d\n",res);
}
PRE(read)
{
/* size_t read(int fd, void *buf, size_t count); */
- MAYBE_PRINTF("read ( %d, %p, %llu )\n", arg1, arg2, (ULong)arg3);
+ PRINT("read ( %d, %p, %llu )", arg1, arg2, (ULong)arg3);
if (!fd_allowed(arg1, "read", tid, False))
set_result( -VKI_EBADF );
else
- SYSCALL_TRACK( pre_mem_write, tid, "read(buf)", arg2, arg3 );
+ PRE_MEM_WRITE( "read(buf)", arg2, arg3 );
}
POST(read)
{
- VG_TRACK( post_mem_write, arg2, res );
+ POST_MEM_WRITE( arg2, res );
}
PRE(write)
{
/* size_t write(int fd, const void *buf, size_t count); */
- MAYBE_PRINTF("write ( %d, %p, %llu )\n", arg1, arg2, (ULong)arg3);
+ PRINT("write ( %d, %p, %llu )", arg1, arg2, (ULong)arg3);
if (!fd_allowed(arg1, "write", tid, False))
set_result( -VKI_EBADF );
else
- SYSCALL_TRACK( pre_mem_read, tid, "write(buf)", arg2, arg3 );
+ PRE_MEM_READ( "write(buf)", arg2, arg3 );
}
PRE(creat)
{
/* int creat(const char *pathname, mode_t mode); */
- MAYBE_PRINTF("creat ( %p(%s), %d ) --> ",arg1,arg1,arg2);
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "creat(pathname)", arg1 );
+ PRINT("creat ( %p(%s), %d ) --> ",arg1,arg1,arg2);
+ PRE_MEM_RASCIIZ( "creat(pathname)", arg1 );
}
POST(creat)
@@ -4299,15 +4209,14 @@
if (VG_(clo_track_fds))
record_fd_open(tid, res, VG_(arena_strdup)(VG_AR_CORE, (Char*)arg1));
}
- MAYBE_PRINTF("%d\n",res);
+ PRINT("%d\n",res);
}
PRE(pipe)
{
/* int pipe(int filedes[2]); */
- MAYBE_PRINTF("pipe ( %p ) ...\n", arg1);
- SYSCALL_TRACK( pre_mem_write, tid, "pipe(filedes)",
- arg1, 2*sizeof(int) );
+ PRINT("pipe ( %p )", arg1);
+ PRE_MEM_WRITE( "pipe(filedes)", arg1, 2*sizeof(int) );
}
POST(pipe)
@@ -4320,40 +4229,35 @@
VG_(close)(p[1]);
set_result( -VKI_EMFILE );
} else {
- VG_TRACK( post_mem_write, arg1, 2*sizeof(int) );
+ POST_MEM_WRITE( arg1, 2*sizeof(int) );
if (VG_(clo_track_fds)) {
record_fd_open(tid, p[0], NULL);
record_fd_open(tid, p[1], NULL);
}
}
-
- MAYBE_PRINTF("SYSCALL[%d] pipe --> %d (rd %d, wr %d)\n",
- VG_(getpid)(), res,
- ((Int*)arg1)[0], ((Int*)arg1)[1] );
}
PRE(poll)
{
/* struct pollfd {
- int fd; -- file descriptor
- short events; -- requested events
- short revents; -- returned events
+ int fd; -- file descriptor
+ short events; -- requested events
+ short revents; -- returned events
};
int poll(struct pollfd *ufds, unsigned int nfds, int timeout)
*/
UInt i;
struct vki_pollfd* ufds = (struct vki_pollfd *)arg1;
- MAYBE_PRINTF("poll ( %p, %d, %d )\n",arg1,arg2,arg3);
-
+ PRINT("poll ( %p, %d, %d )\n",arg1,arg2,arg3);
+
for (i = 0; i < arg2; i++) {
// 'fd' and 'events' field are inputs; 'revents' is output.
// XXX: this is x86 specific -- the pollfd struct varies across
// different architectures.
- SYSCALL_TRACK( pre_mem_read, tid, "poll(ufds)",
- (Addr)(&ufds[i]), sizeof(int) + sizeof(short) );
- SYSCALL_TRACK( pre_mem_write, tid, "poll(ufds)",
- (Addr)(&ufds[i].revents), sizeof(short) );
- }
+ PRE_MEM_READ( "poll(ufds)",
+ (Addr)(&ufds[i]), sizeof(int) + sizeof(short) );
+ PRE_MEM_WRITE( "poll(ufds)", (Addr)(&ufds[i].revents), sizeof(short) );
+ }
}
POST(poll)
@@ -4363,15 +4267,14 @@
struct vki_pollfd* ufds = (struct vki_pollfd *)arg1;
// XXX: again, this is x86-specific
for (i = 0; i < arg2; i++)
- VG_TRACK( post_mem_write, (Addr)(&ufds[i].revents),
- sizeof(short) );
+ POST_MEM_WRITE( (Addr)(&ufds[i].revents), sizeof(Short) );
}
}
PRE(epoll_create)
{
/* int epoll_create(int size) */
- MAYBE_PRINTF("epoll_create ( %d )\n", arg1);
+ PRINT("epoll_create ( %d )", arg1);
}
POST(epoll_create)
@@ -4393,38 +4296,36 @@
"EPOLL_CTL_DEL",
"EPOLL_CTL_MOD"
};
- MAYBE_PRINTF("epoll_ctl ( %d, %s, %d, %p )\n",
+ PRINT("epoll_ctl ( %d, %s, %d, %p )",
arg1, ( arg2<3 ? epoll_ctl_s[arg2] : "?" ), arg3, arg4);
- SYSCALL_TRACK( pre_mem_read, tid, "epoll_ctl(event)",
- arg4, sizeof(struct epoll_event) );
+ PRE_MEM_READ( "epoll_ctl(event)", arg4, sizeof(struct epoll_event) );
}
PRE(epoll_wait)
{
/* int epoll_wait(int epfd, struct epoll_event * events,
int maxevents, int timeout) */
- MAYBE_PRINTF("epoll_wait ( %d, %p, %d, %d )\n", arg1, arg2, arg3, arg4);
- SYSCALL_TRACK( pre_mem_write, tid, "epoll_wait(events)",
- arg2, sizeof(struct epoll_event)*arg3);
+ PRINT("epoll_wait ( %d, %p, %d, %d )", arg1, arg2, arg3, arg4);
+ PRE_MEM_WRITE( "epoll_wait(events)", arg2, sizeof(struct epoll_event)*arg3);
}
POST(epoll_wait)
{
if (res > 0)
- VG_TRACK( post_mem_write, arg2, sizeof(struct epoll_event)*res ) ;
+ POST_MEM_WRITE( arg2, sizeof(struct epoll_event)*res ) ;
}
PRE(readlink)
{
/* int readlink(const char *path, char *buf, size_t bufsiz); */
- MAYBE_PRINTF("readlink ( %p, %p, %llu )\n", arg1,arg2,(ULong)arg3);
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "readlink(path)", arg1 );
- SYSCALL_TRACK( pre_mem_write, tid, "readlink(buf)", arg2,arg3 );
+ PRINT("readlink ( %p, %p, %llu )", arg1,arg2,(ULong)arg3);
+ PRE_MEM_RASCIIZ( "readlink(path)", arg1 );
+ PRE_MEM_WRITE( "readlink(buf)", arg2,arg3 );
}
POST(readlink)
{
- VG_TRACK( post_mem_write, arg2, res );
+ POST_MEM_WRITE( arg2, res );
}
PRE(readv)
@@ -4432,16 +4333,15 @@
/* int readv(int fd, const struct iovec * vector, size_t count); */
Int i;
struct vki_iovec * vec;
- MAYBE_PRINTF("readv ( %d, %p, %llu )\n",arg1,arg2,(ULong)arg3);
+ PRINT("readv ( %d, %p, %llu )",arg1,arg2,(ULong)arg3);
if (!fd_allowed(arg1, "readv", tid, False)) {
set_result( -VKI_EBADF );
} else {
- SYSCALL_TRACK( pre_mem_read, tid, "readv(vector)",
- arg2, arg3 * sizeof(struct vki_iovec) );
+ PRE_MEM_READ( "readv(vector)", arg2, arg3 * sizeof(struct vki_iovec) );
/* ToDo: don't do any of the following if the vector is invalid */
vec = (struct vki_iovec *)arg2;
for (i = 0; i < (Int)arg3; i++)
- SYSCALL_TRACK( pre_mem_write, tid, "readv(vector[...])",
+ PRE_MEM_WRITE( "readv(vector[...])",
(Addr)vec[i].iov_base, vec[i].iov_len );
}
}
@@ -4457,7 +4357,7 @@
for (i = 0; i < (Int)arg3; i++) {
Int nReadThisBuf = vec[i].iov_len;
if (nReadThisBuf > remains) nReadThisBuf = remains;
- VG_TRACK( post_mem_write, (Addr)vec[i].iov_base, nReadThisBuf );
+ POST_MEM_WRITE( (Addr)vec[i].iov_base, nReadThisBuf );
remains -= nReadThisBuf;
if (remains < 0) VG_(core_panic)("readv: remains < 0");
}
@@ -4467,48 +4367,47 @@
PRE(rename)
{
/* int rename(const char *oldpath, const char *newpath); */
- MAYBE_PRINTF("rename ( %p, %p )\n", arg1, arg2 );
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "rename(oldpath)", arg1 );
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "rename(newpath)", arg2 );
+ PRINT("rename ( %p, %p )", arg1, arg2 );
+ PRE_MEM_RASCIIZ( "rename(oldpath)", arg1 );
+ PRE_MEM_RASCIIZ( "rename(newpath)", arg2 );
}
PRE(rmdir)
{
/* int rmdir(const char *pathname); */
- MAYBE_PRINTF("rmdir ( %p )\n", arg1);
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "rmdir(pathname)", arg1 );
+ PRINT("rmdir ( %p )", arg1);
+ PRE_MEM_RASCIIZ( "rmdir(pathname)", arg1 );
}
PRE(sched_setparam)
{
/* int sched_setparam(pid_t pid, const struct sched_param *p); */
- MAYBE_PRINTF("sched_setparam ( %d, %p )\n", arg1, arg2 );
- SYSCALL_TRACK( pre_mem_read, tid, "sched_setparam(ptr)",
- arg2, sizeof(struct vki_sched_param) );
+ PRINT("sched_setparam ( %d, %p )", arg1, arg2 );
+ PRE_MEM_READ( "sched_setparam(ptr)", arg2, sizeof(struct vki_sched_param) );
}
POST(sched_setparam)
{
- VG_TRACK( post_mem_write, arg2, sizeof(struct vki_sched_param) );
+ POST_MEM_WRITE( arg2, sizeof(struct vki_sched_param) );
}
PRE(sched_getparam)
{
/* int sched_getparam(pid_t pid, struct sched_param *p); */
- MAYBE_PRINTF("sched_getparam ( %d, %p )\n", arg1, arg2 );
- SYSCALL_TRACK( pre_mem_write, tid, "sched_getparam(ptr)",
+ PRINT("sched_getparam ( %d, %p )", arg1, arg2 );
+ PRE_MEM_WRITE( "sched_getparam(ptr)",
arg2, sizeof(struct vki_sched_param) );
}
POST(sched_getparam)
{
- VG_TRACK( post_mem_write, arg2, sizeof(struct vki_sched_param) );
+ POST_MEM_WRITE( arg2, sizeof(struct vki_sched_param) );
}
PRE(sched_yield)
{
/* int sched_yield(void); */
- MAYBE_PRINTF("sched_yield ()\n" );
+ PRINT("sched_yield ()" );
}
PRE(select)
@@ -4520,7 +4419,7 @@
};
int old_select(struct sel_arg_struct *arg);
*/
- SYSCALL_TRACK( pre_mem_read, tid, "select(args)", arg1, 5*sizeof(UInt) );
+ PRE_MEM_READ( "select(args)", arg1, 5*sizeof(UInt) );
{
UInt* arg_struct = (UInt*)arg1;
@@ -4532,34 +4431,27 @@
a4 = arg_struct[3];
a5 = arg_struct[4];
- MAYBE_PRINTF("select ( %d, %p, %p, %p, %p )\n",
- a1,a2,a3,a4,a5);
+ PRINT("select ( %d, %p, %p, %p, %p )", a1,a2,a3,a4,a5);
if (a2 != (Addr)NULL)
- SYSCALL_TRACK( pre_mem_read, tid, "select(readfds)", a2,
- a1/8 /* __FD_SETSIZE/8 */ );
+ PRE_MEM_READ( "select(readfds)", a2, a1/8 /* __FD_SETSIZE/8 */ );
if (a3 != (Addr)NULL)
- SYSCALL_TRACK( pre_mem_read, tid, "select(writefds)", a3,
- a1/8 /* __FD_SETSIZE/8 */ );
+ PRE_MEM_READ( "select(writefds)", a3, a1/8 /* __FD_SETSIZE/8 */ );
if (a4 != (Addr)NULL)
- SYSCALL_TRACK( pre_mem_read, tid, "select(exceptfds)", a4,
- a1/8 /* __FD_SETSIZE/8 */ );
+ PRE_MEM_READ( "select(exceptfds)", a4, a1/8 /* __FD_SETSIZE/8 */ );
if (a5 != (Addr)NULL)
- SYSCALL_TRACK( pre_mem_read, tid, "select(timeout)", a5,
- sizeof(struct vki_timeval) );
+ PRE_MEM_READ( "select(timeout)", a5, sizeof(struct vki_timeval) );
}
}
PRE(setitimer)
{
- /* setitimer(int which, const struct itimerval *value,
- struct itimerval *ovalue); */
- MAYBE_PRINTF("setitimer ( %d, %p, %p )\n", arg1,arg2,arg3);
- if (arg2 != (Addr)NULL)
- SYSCALL_TRACK( pre_mem_read,tid, "setitimer(value)",
- arg2, sizeof(struct vki_itimerval) );
- if (arg3 != (Addr)NULL)
- SYSCALL_TRACK( pre_mem_write,tid, "setitimer(ovalue)",
- arg3, sizeof(struct vki_itimerval));
+ /* setitimer(int which, const struct itimerval *value,
+ struct itimerval *ovalue); */
+ PRINT("setitimer ( %d, %p, %p )", arg1,arg2,arg3);
+ if (arg2 != (Addr)NULL)
+ PRE_MEM_READ( "setitimer(value)", arg2, sizeof(struct vki_itimerval) );
+ if (arg3 != (Addr)NULL)
+ PRE_MEM_WRITE( "setitimer(ovalue)", arg3, sizeof(struct vki_itimerval));
}
POST(setitimer)
@@ -4572,13 +4464,13 @@
PRE(setfsgid32)
{
/* int setfsgid(uid_t fsgid); */
- MAYBE_PRINTF("setfsgid ( %d )\n", arg1);
+ PRINT("setfsgid ( %d )", arg1);
}
PRE(setgid)
{
/* int setgid(gid_t gid); */
- MAYBE_PRINTF("setgid ( %d )\n", arg1);
+ PRINT("setgid ( %d )", arg1);
}
PREALIAS(setgid32, setgid);
@@ -4586,16 +4478,15 @@
PRE(setsid)
{
/* pid_t setsid(void); */
- MAYBE_PRINTF("setsid ()\n");
+ PRINT("setsid ()");
}
PRE(setgroups)
{
/* int setgroups(size_t size, const gid_t *list); */
- MAYBE_PRINTF("setgroups ( %llu, %p )\n", (ULong)arg1, arg2);
+ PRINT("setgroups ( %llu, %p )", (ULong)arg1, arg2);
if (arg1 > 0)
- SYSCALL_TRACK( pre_mem_read, tid, "setgroups(list)", arg2,
- arg1 * sizeof(vki_gid_t) );
+ PRE_MEM_READ( "setgroups(list)", arg2, arg1 * sizeof(vki_gid_t) );
}
PREALIAS(setgroups32, setgroups);
@@ -4603,7 +4494,7 @@
PRE(setpgid)
{
/* int setpgid(pid_t pid, pid_t pgid); */
- MAYBE_PRINTF("setpgid ( %d, %d )\n", arg1, arg2);
+ PRINT("setpgid ( %d, %d )", arg1, arg2);
}
POST(setpgid)
@@ -4614,19 +4505,19 @@
PRE(setregid32)
{
/* int setregid(gid_t rgid, gid_t egid); */
- MAYBE_PRINTF("setregid32(?) ( %d, %d )\n", arg1, arg2);
+ PRINT("setregid32(?) ( %d, %d )", arg1, arg2);
}
PRE(setresuid32)
{
/* int setresuid(uid_t ruid, uid_t euid, uid_t suid); */
- MAYBE_PRINTF("setresuid32(?) ( %d, %d, %d )\n", arg1, arg2, arg3);
+ PRINT("setresuid32(?) ( %d, %d, %d )", arg1, arg2, arg3);
}
PRE(setreuid)
{
/* int setreuid(uid_t ruid, uid_t euid); */
- MAYBE_PRINTF("setreuid ( 0x%x, 0x%x )\n", arg1, arg2);
+ PRINT("setreuid ( 0x%x, 0x%x )", arg1, arg2);
}
PREALIAS(setreuid32, setreuid);
@@ -4634,9 +4525,8 @@
PRE(setrlimit)
{
/* int setrlimit (int resource, const struct rlimit *rlim); */
- MAYBE_PRINTF("setrlimit ( %d, %p )\n", arg1,arg2);
- SYSCALL_TRACK( pre_mem_read, tid, "setrlimit(rlim)",
- arg2, sizeof(struct vki_rlimit) );
+ PRINT("setrlimit ( %d, %p )", arg1,arg2);
+ PRE_MEM_READ( "setrlimit(rlim)", arg2, sizeof(struct vki_rlimit) );
if (arg1 == VKI_RLIMIT_NOFILE) {
if (((struct vki_rlimit *)arg2)->rlim_cur > VG_(fd_hard_limit) ||
@@ -4674,12 +4564,10 @@
PRE(settimeofday)
{
/* int settimeofday(const struct timeval *tv, const struct timezone *tz); */
- MAYBE_PRINTF("settimeofday ( %p, %p )\n",arg1,arg2);
- SYSCALL_TRACK( pre_mem_read, tid, "settimeofday(tv)", arg1,
- sizeof(struct vki_timeval) );
+ PRINT("settimeofday ( %p, %p )",arg1,arg2);
+ PRE_MEM_READ( "settimeofday(tv)", arg1, sizeof(struct vki_timeval) );
if (arg2 != 0) {
- SYSCALL_TRACK( pre_mem_read, tid, "settimeofday(tz)", arg2,
- sizeof(struct vki_timezone) );
+ PRE_MEM_READ( "settimeofday(tz)", arg2, sizeof(struct vki_timezone) );
/* maybe should warn if tz->tz_dsttime is non-zero? */
}
}
@@ -4687,7 +4575,7 @@
PRE(setuid)
{
/* int setuid(uid_t uid); */
- MAYBE_PRINTF("setuid ( %d )\n", arg1);
+ PRINT("setuid ( %d )", arg1);
}
PREALIAS(setuid32, setuid);
@@ -4695,42 +4583,37 @@
PRE(socketcall)
{
/* int socketcall(int call, unsigned long *args); */
- MAYBE_PRINTF("socketcall ( %d, %p )\n",arg1,arg2);
+ PRINT("socketcall ( %d, %p )",arg1,arg2);
switch (arg1 /* request */) {
case VKI_SYS_SOCKETPAIR:
/* int socketpair(int d, int type, int protocol, int sv[2]); */
- SYSCALL_TRACK( pre_mem_read, tid, "socketcall.socketpair(args)",
- arg2, 4*sizeof(Addr) );
- SYSCALL_TRACK( pre_mem_write, tid, "socketcall.socketpair(sv)",
+ PRE_MEM_READ( "socketcall.socketpair(args)", arg2, 4*sizeof(Addr) );
+ PRE_MEM_WRITE( "socketcall.socketpair(sv)",
((UWord*)arg2)[3], 2*sizeof(int) );
break;
case VKI_SYS_SOCKET:
/* int socket(int domain, int type, int protocol); */
- SYSCALL_TRACK( pre_mem_read, tid, "socketcall.socket(args)",
- arg2, 3*sizeof(Addr) );
+ PRE_MEM_READ( "socketcall.socket(args)", arg2, 3*sizeof(Addr) );
break;
case VKI_SYS_BIND:
/* int bind(int sockfd, struct sockaddr *my_addr,
int addrlen); */
- SYSCALL_TRACK( pre_mem_read, tid, "socketcall.bind(args)",
- arg2, 3*sizeof(Addr) );
+ PRE_MEM_READ( "socketcall.bind(args)", arg2, 3*sizeof(Addr) );
pre_mem_read_sockaddr( tid, "socketcall.bind(my_addr.%s)",
(struct vki_sockaddr *) (((UWord*)arg2)[1]), ((UWord*)arg2)[2]);
break;
case VKI_SYS_LISTEN:
/* int listen(int s, int backlog); */
- SYSCALL_TRACK( pre_mem_read, tid, "socketcall.listen(args)",
- arg2, 2*sizeof(Addr) );
+ PRE_MEM_READ( "socketcall.listen(args)", arg2, 2*sizeof(Addr) );
break;
case VKI_SYS_ACCEPT: {
/* int accept(int s, struct sockaddr *addr, int *addrlen); */
- SYSCALL_TRACK( pre_mem_read, tid, "socketcall.accept(args)",
- arg2, 3*sizeof(Addr) );
+ PRE_MEM_READ( "socketcall.accept(args)", arg2, 3*sizeof(Addr) );
{
Addr addr_p = ((UWord*)arg2)[1];
Addr addrlen_p = ((UWord*)arg2)[2];
@@ -4746,9 +4629,8 @@
/* int sendto(int s, const void *msg, int len,
unsigned int flags,
const struct sockaddr *to, int tolen); */
- SYSCALL_TRACK( pre_mem_read, tid, "socketcall.sendto(args)", arg2,
- 6*sizeof(Addr) );
- SYSCALL_TRACK( pre_mem_read, tid, "socketcall.sendto(msg)",
+ PRE_MEM_READ( "socketcall.sendto(args)", arg2, 6*sizeof(Addr) );
+ PRE_MEM_READ( "socketcall.sendto(msg)",
((UWord*)arg2)[1], /* msg */
((UWord*)arg2)[2] /* len */ );
pre_mem_read_sockaddr( tid, "socketcall.sendto(to.%s)",
@@ -4757,9 +4639,8 @@
case VKI_SYS_SEND:
/* int send(int s, const void *msg, size_t len, int flags); */
- SYSCALL_TRACK( pre_mem_read, tid, "socketcall.send(args)", arg2,
- 4*sizeof(Addr) );
- SYSCALL_TRACK( pre_mem_read, tid, "socketcall.send(msg)",
+ PRE_MEM_READ( "socketcall.send(args)", arg2, 4*sizeof(Addr) );
+ PRE_MEM_READ( "socketcall.send(msg)",
((UWord*)arg2)[1], /* msg */
((UWord*)arg2)[2] /* len */ );
break;
@@ -4767,16 +4648,14 @@
case VKI_SYS_RECVFROM:
/* int recvfrom(int s, void *buf, int len, unsigned int flags,
struct sockaddr *from, int *fromlen); */
- SYSCALL_TRACK( pre_mem_read, tid, "socketcall.recvfrom(args)",
- arg2, 6*sizeof(Addr) );
+ PRE_MEM_READ( "socketcall.recvfrom(args)", arg2, 6*sizeof(Addr) );
{
Addr buf_p = ((UWord*)arg2)[1];
Int len = ((UWord*)arg2)[2];
Addr from_p = ((UWord*)arg2)[4];
Addr fromlen_p = ((UWord*)arg2)[5];
- SYSCALL_TRACK( pre_mem_write, tid, "socketcall.recvfrom(buf)",
- buf_p, len );
+ PRE_MEM_WRITE( "socketcall.recvfrom(buf)", buf_p, len );
if (from_p != (Addr)NULL)
buf_and_len_pre_check ( tid, from_p, fromlen_p,
"socketcall.recvfrom(from)",
@@ -4791,9 +4670,8 @@
(see connect(2)) and is identical to recvfrom with a NULL
from parameter.
*/
- SYSCALL_TRACK( pre_mem_read, tid, "socketcall.recv(args)",
- arg2, 4*sizeof(Addr) );
- SYSCALL_TRACK( pre_mem_write, tid, "socketcall.recv(buf)",
+ PRE_MEM_READ( "socketcall.recv(args)", arg2, 4*sizeof(Addr) );
+ PRE_MEM_WRITE( "socketcall.recv(buf)",
((UWord*)arg2)[1], /* buf */
((UWord*)arg2)[2] /* len */ );
break;
@@ -4801,10 +4679,8 @@
case VKI_SYS_CONNECT:
/* int connect(int sockfd,
struct sockaddr *serv_addr, int addrlen ); */
- SYSCALL_TRACK( pre_mem_read, tid, "socketcall.connect(args)",
- arg2, 3*sizeof(Addr) );
- SYSCALL_TRACK( pre_mem_read, tid,
- "socketcall.connect(serv_addr.sa_family)",
+ PRE_MEM_READ( "socketcall.connect(args)", arg2, 3*sizeof(Addr) );
+ PRE_MEM_READ( "socketcall.connect(serv_addr.sa_family)",
((UWord*)arg2)[1], /* serv_addr */
sizeof(vki_sa_family_t));
pre_mem_read_sockaddr( tid,
@@ -4815,9 +4691,8 @@
case VKI_SYS_SETSOCKOPT:
/* int setsockopt(int s, int level, int optname,
const void *optval, int optlen); */
- SYSCALL_TRACK( pre_mem_read, tid, "socketcall.setsockopt(args)",
- arg2, 5*sizeof(Addr) );
- SYSCALL_TRACK( pre_mem_read, tid, "socketcall.setsockopt(optval)",
+ PRE_MEM_READ( "socketcall.setsockopt(args)", arg2, 5*sizeof(Addr) );
+ PRE_MEM_READ( "socketcall.setsockopt(optval)",
((UWord*)arg2)[3], /* optval */
((UWord*)arg2)[4] /* optlen */ );
break;
@@ -4825,8 +4700,7 @@
case VKI_SYS_GETSOCKOPT:
/* int setsockopt(int s, int level, int optname,
void *optval, socklen_t *optlen); */
- SYSCALL_TRACK( pre_mem_read, tid, "socketcall.getsockopt(args)",
- arg2, 5*sizeof(Addr) );
+ PRE_MEM_READ( "socketcall.getsockopt(args)", arg2, 5*sizeof(Addr) );
{
Addr optval_p = ((UWord*)arg2)[3];
Addr optlen_p = ((UWord*)arg2)[4];
@@ -4840,8 +4714,7 @@
case VKI_SYS_GETSOCKNAME:
/* int getsockname(int s, struct sockaddr* name, int* namelen) */
- SYSCALL_TRACK( pre_mem_read, tid, "socketcall.getsockname(args)",
- arg2, 3*sizeof(Addr) );
+ PRE_MEM_READ( "socketcall.getsockname(args)", arg2, 3*sizeof(Addr) );
{
Addr name_p = ((UWord*)arg2)[1];
Addr namelen_p = ((UWord*)arg2)[2];
@@ -4855,8 +4728,7 @@
case VKI_SYS_GETPEERNAME:
/* int getpeername(int s, struct sockaddr* name, int* namelen) */
- SYSCALL_TRACK( pre_mem_read, tid, "socketcall.getpeername(args)",
- arg2, 3*sizeof(Addr) );
+ PRE_MEM_READ( "socketcall.getpeername(args)", arg2, 3*sizeof(Addr) );
{
Addr name_p = ((UWord*)arg2)[1];
Addr namelen_p = ((UWord*)arg2)[2];
@@ -4870,8 +4742,7 @@
case VKI_SYS_SHUTDOWN:
/* int shutdown(int s, int how); */
- SYSCALL_TRACK( pre_mem_read, tid, "socketcall.shutdown(args)",
- arg2, 2*sizeof(Addr) );
+ PRE_MEM_READ( "socketcall.shutdown(args)", arg2, 2*sizeof(Addr) );
break;
case VKI_SYS_SENDMSG: {
@@ -4879,8 +4750,7 @@
/* this causes warnings, and I don't get why. glibc bug?
* (after all it's glibc providing the arguments array)
- SYSCALL_TRACK( pre_mem_read, "socketcall.sendmsg(args)",
- arg2, 3*sizeof(Addr) );
+ PRE_MEM_READ( "socketcall.sendmsg(args)", arg2, 3*sizeof(Addr) );
*/
struct vki_msghdr *msg = (struct vki_msghdr *)((UWord*)arg2)[ 1 ];
@@ -4894,8 +4764,7 @@
/* this causes warnings, and I don't get why. glibc bug?
* (after all it's glibc providing the arguments array)
- SYSCALL_TRACK( pre_mem_read, "socketcall.recvmsg(args)",
- arg2, 3*sizeof(Addr) );
+ PRE_MEM_READ("socketcall.recvmsg(args)", arg2, 3*sizeof(Addr) );
*/
struct vki_msghdr *msg = (struct vki_msghdr *)((UWord*)arg2)[ 1 ];
@@ -4914,21 +4783,21 @@
POST(socketcall)
{
/* int socketcall(int call, unsigned long *args); */
- MAYBE_PRINTF("socketcall ( %d, %p )\n",arg1,arg2);
+ PRINT("socketcall ( %d, %p )",arg1,arg2);
switch (arg1 /* request */) {
case VKI_SYS_SOCKETPAIR: {
Int fd1 = ((Int*)((UWord*)arg2)[3])[0];
Int fd2 = ((Int*)((UWord*)arg2)[3])[1];
- VG_TRACK( post_mem_write, ((UWord*)arg2)[3], 2*sizeof(int) );
+ POST_MEM_WRITE( ((UWord*)arg2)[3], 2*sizeof(int) );
if (!fd_allowed(fd1, "socketcall.socketpair", tid, True) ||
!fd_allowed(fd2, "socketcall.socketpair", tid, True)) {
VG_(close)(fd1);
VG_(close)(fd2);
set_result( -VKI_EMFILE );
} else {
- VG_TRACK( post_mem_write, ((UWord*)arg2)[3], 2*sizeof(int) );
+ POST_MEM_WRITE( ((UWord*)arg2)[3], 2*sizeof(int) );
if (VG_(clo_track_fds)) {
record_fd_open(tid, fd1, NULL);
record_fd_open(tid, fd2, NULL);
@@ -4990,15 +4859,15 @@
if (from_p != (Addr)NULL)
buf_and_len_post_check ( tid, res, from_p, fromlen_p,
"socketcall.recvfrom(fromlen_out)" );
- VG_TRACK( post_mem_write, buf_p, len );
+ POST_MEM_WRITE( buf_p, len );
}
break;
case VKI_SYS_RECV:
if (res >= 0
&& ((UWord*)arg2)[1] != (UWord)NULL) {
- VG_TRACK( post_mem_write, ((UWord*)arg2)[1], /* buf */
- ((UWord*)arg2)[2] /* len */ );
+ POST_MEM_WRITE( ((UWord*)arg2)[1], /* buf */
+ ((UWord*)arg2)[2] /* len */ );
}
break;
@@ -5065,207 +4934,194 @@
PRE(stat)
{
/* int stat(const char *file_name, struct stat *buf); */
- MAYBE_PRINTF("stat ( %p, %p )\n",arg1,arg2);
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "stat(file_name)", arg1 );
- SYSCALL_TRACK( pre_mem_write, tid, "stat(buf)",
- arg2, sizeof(struct vki_stat) );
+ PRINT("stat ( %p, %p )",arg1,arg2);
+ PRE_MEM_RASCIIZ( "stat(file_name)", arg1 );
+ PRE_MEM_WRITE( "stat(buf)", arg2, sizeof(struct vki_stat) );
}
POST(stat)
{
- VG_TRACK( post_mem_write, arg2, sizeof(struct vki_stat) );
+ POST_MEM_WRITE( arg2, sizeof(struct vki_stat) );
}
PRE(statfs)
{
/* int statfs(const char *path, struct statfs *buf); */
- MAYBE_PRINTF("statfs ( %p, %p )\n",arg1,arg2);
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "statfs(path)", arg1 );
- SYSCALL_TRACK( pre_mem_write, tid, "statfs(buf)",
- arg2, sizeof(struct vki_statfs) );
+ PRINT("statfs ( %p, %p )",arg1,arg2);
+ PRE_MEM_RASCIIZ( "statfs(path)", arg1 );
+ PRE_MEM_WRITE( "statfs(buf)", arg2, sizeof(struct vki_statfs) );
}
POST(statfs)
{
- VG_TRACK( post_mem_write, arg2, sizeof(struct vki_statfs) );
+ POST_MEM_WRITE( arg2, sizeof(struct vki_statfs) );
}
PRE(statfs64)
{
/* int statfs64(const char *path, size_t sz, struct statfs64 *buf); */
- MAYBE_PRINTF("statfs64 ( %p, %llu, %p )\n",arg1,(ULong)arg2,arg3);
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "statfs64(path)", arg1 );
- SYSCALL_TRACK( pre_mem_write, tid, "statfs64(buf)", arg3, arg2 );
+ PRINT("statfs64 ( %p, %llu, %p )",arg1,(ULong)arg2,arg3);
+ PRE_MEM_RASCIIZ( "statfs64(path)", arg1 );
+ PRE_MEM_WRITE( "statfs64(buf)", arg3, arg2 );
}
POST(statfs64)
{
- VG_TRACK( post_mem_write, arg3, arg2 );
+ POST_MEM_WRITE( arg3, arg2 );
}
PRE(symlink)
{
/* int symlink(const char *oldpath, const char *newpath); */
- MAYBE_PRINTF("symlink ( %p, %p )\n",arg1,arg2);
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "symlink(oldpath)", arg1 );
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "symlink(newpath)", arg2 );
+ PRINT("symlink ( %p, %p )",arg1,arg2);
+ PRE_MEM_RASCIIZ( "symlink(oldpath)", arg1 );
+ PRE_MEM_RASCIIZ( "symlink(newpath)", arg2 );
}
PRE(stat64)
{
/* int stat64(const char *file_name, struct stat64 *buf); */
- MAYBE_PRINTF("stat64 ( %p, %p )\n",arg1,arg2);
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "stat64(file_name)", arg1 );
- SYSCALL_TRACK( pre_mem_write, tid, "stat64(buf)",
- arg2, sizeof(struct vki_stat64) );
+ PRINT("stat64 ( %p, %p )",arg1,arg2);
+ PRE_MEM_RASCIIZ( "stat64(file_name)", arg1 );
+ PRE_MEM_WRITE( "stat64(buf)", arg2, sizeof(struct vki_stat64) );
}
POST(stat64)
{
- VG_TRACK( post_mem_write, arg2, sizeof(struct vki_stat64) );
+ POST_MEM_WRITE( arg2, sizeof(struct vki_stat64) );
}
PRE(fstat64)
{
/* int fstat64(int filedes, struct stat64 *buf); */
- MAYBE_PRINTF("fstat64 ( %d, %p )\n",arg1,arg2);
- SYSCALL_TRACK( pre_mem_write, tid, "fstat64(buf)",
- arg2, sizeof(struct vki_stat64) );
+ PRINT("fstat64 ( %d, %p )",arg1,arg2);
+ PRE_MEM_WRITE( "fstat64(buf)", arg2, sizeof(struct vki_stat64) );
}
POST(fstat64)
{
- VG_TRACK( post_mem_write, arg2, sizeof(struct vki_stat64) );
+ POST_MEM_WRITE( arg2, sizeof(struct vki_stat64) );
}
PRE(sysinfo)
{
/* int sysinfo(struct sysinfo *info); */
- MAYBE_PRINTF("sysinfo ( %p )\n",arg1);
- SYSCALL_TRACK( pre_mem_write, tid, "sysinfo(info)",
- arg1, sizeof(struct vki_sysinfo) );
+ PRINT("sysinfo ( %p )",arg1);
+ PRE_MEM_WRITE( "sysinfo(info)", arg1, sizeof(struct vki_sysinfo) );
}
POST(sysinfo)
{
- VG_TRACK( post_mem_write, arg1, sizeof(struct vki_sysinfo) );
+ POST_MEM_WRITE( arg1, sizeof(struct vki_sysinfo) );
}
PRE(time)
{
/* time_t time(time_t *t); */
- MAYBE_PRINTF("time ( %p )\n",arg1);
+ PRINT("time ( %p )",arg1);
if (arg1 != (UWord)NULL) {
- SYSCALL_TRACK( pre_mem_write, tid, "time", arg1, sizeof(vki_time_t) );
+ PRE_MEM_WRITE( "time", arg1, sizeof(vki_time_t) );
}
}
POST(time)
{
if (arg1 != (UWord)NULL) {
- VG_TRACK( post_mem_write, arg1, sizeof(vki_time_t) );
+ POST_MEM_WRITE( arg1, sizeof(vki_time_t) );
}
}
PRE(times)
{
/* clock_t times(struct tms *buf); */
- MAYBE_PRINTF("times ( %p )\n",arg1);
- SYSCALL_TRACK( pre_mem_write, tid, "times(buf)",
- arg1, sizeof(struct vki_tms) );
+ PRINT("times ( %p )",arg1);
+ PRE_MEM_WRITE( "times(buf)", arg1, sizeof(struct vki_tms) );
}
POST(times)
{
if (arg1 != (UWord)NULL) {
- VG_TRACK( post_mem_write, arg1, sizeof(struct vki_tms) );
+ POST_MEM_WRITE( arg1, sizeof(struct vki_tms) );
}
}
PRE(truncate)
{
/* int truncate(const char *path, off_t length); */
- MAYBE_PRINTF("truncate ( %p(%s), %d )\n", arg1,arg1,arg2);
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "truncate(path)", arg1 );
+ PRINT("truncate ( %p(%s), %d )", arg1,arg1,arg2);
+ PRE_MEM_RASCIIZ( "truncate(path)", arg1 );
}
PRE(umask)
{
/* mode_t umask(mode_t mask); */
- MAYBE_PRINTF("umask ( %d )\n", arg1);
+ PRINT("umask ( %d )", arg1);
}
PRE(unlink)
{
/* int unlink(const char *pathname) */
- MAYBE_PRINTF("unlink ( %p(%s) )\n",arg1, arg1);
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "unlink(pathname)", arg1 );
+ PRINT("unlink ( %p(%s) )",arg1, arg1);
+ PRE_MEM_RASCIIZ( "unlink(pathname)", arg1 );
}
PRE(uname)
{
/* int uname(struct utsname *buf); */
- MAYBE_PRINTF("uname ( %p )\n",arg1);
- SYSCALL_TRACK( pre_mem_write, tid, "uname(buf)",
- arg1, sizeof(struct vki_new_utsname) );
+ PRINT("uname ( %p )",arg1);
+ PRE_MEM_WRITE( "uname(buf)", arg1, sizeof(struct vki_new_utsname) );
}
POST(uname)
{
if (arg1 != (UWord)NULL) {
- VG_TRACK( post_mem_write, arg1, sizeof(struct vki_new_utsname) );
+ POST_MEM_WRITE( arg1, sizeof(struct vki_new_utsname) );
}
}
PRE(utime)
{
/* int utime(const char *filename, struct utimbuf *buf); */
- MAYBE_PRINTF("utime ( %p, %p )\n", arg1,arg2);
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "utime(filename)", arg1 );
+ PRINT("utime ( %p, %p )", arg1,arg2);
+ PRE_MEM_RASCIIZ( "utime(filename)", arg1 );
if (arg2 != (UWord)NULL)
- SYSCALL_TRACK( pre_mem_read, tid, "utime(buf)", arg2,
- sizeof(struct vki_utimbuf) );
+ PRE_MEM_READ( "utime(buf)", arg2, sizeof(struct vki_utimbuf) );
}
PRE(waitpid)
{
/* pid_t waitpid(pid_t pid, int *status, int options); */
- MAYBE_PRINTF("waitpid ( %d, %p, %d )\n",
- arg1,arg2,arg3);
+ PRINT("waitpid ( %d, %p, %d )", arg1,arg2,arg3);
if (arg2 != (Addr)NULL)
- SYSCALL_TRACK( pre_mem_write, tid, "waitpid(status)",
- arg2, sizeof(int) );
+ PRE_MEM_WRITE( "waitpid(status)", arg2, sizeof(int) );
}
POST(waitpid)
{
if (arg2 != (Addr)NULL)
- VG_TRACK( post_mem_write, arg2, sizeof(int) );
+ POST_MEM_WRITE( arg2, sizeof(int) );
}
PRE(wait4)
{
/* pid_t wait4(pid_t pid, int *status, int options,
struct rusage *rusage) */
- MAYBE_PRINTF("wait4 ( %d, %p, %d, %p )\n",
- arg1,arg2,arg3,arg4);
+ PRINT("wait4 ( %d, %p, %d, %p )", arg1,arg2,arg3,arg4);
arg3 &= ~(__VKI_WCLONE | __VKI_WALL);
if (arg2 != (Addr)NULL)
- SYSCALL_TRACK( pre_mem_write, tid, "wait4(status)",
- arg2, sizeof(int) );
+ PRE_MEM_WRITE( "wait4(status)", arg2, sizeof(int) );
if (arg4 != (Addr)NULL)
- SYSCALL_TRACK( pre_mem_write, tid, "wait4(rusage)", arg4,
- sizeof(struct vki_rusage) );
+ PRE_MEM_WRITE( "wait4(rusage)", arg4, sizeof(struct vki_rusage) );
}
POST(wait4)
{
if (arg2 != (Addr)NULL)
- VG_TRACK( post_mem_write, arg2, sizeof(int) );
+ POST_MEM_WRITE( arg2, sizeof(int) );
if (arg4 != (Addr)NULL)
- VG_TRACK( post_mem_write, arg4, sizeof(struct vki_rusage) );
+ POST_MEM_WRITE( arg4, sizeof(struct vki_rusage) );
}
PRE(writev)
@@ -5273,16 +5129,16 @@
/* int writev(int fd, const struct iovec * vector, size_t count); */
Int i;
struct vki_iovec * vec;
- MAYBE_PRINTF("writev ( %d, %p, %llu )\n",arg1,arg2,(ULong)arg3);
+ PRINT("writev ( %d, %p, %llu )",arg1,arg2,(ULong)arg3);
if (!fd_allowed(arg1, "writev", tid, False)) {
set_result( -VKI_EBADF );
} else {
- SYSCALL_TRACK( pre_mem_read, tid, "writev(vector)",
+ PRE_MEM_READ( "writev(vector)",
arg2, arg3 * sizeof(struct vki_iovec) );
/* ToDo: don't do any of the following if the vector is invalid */
vec = (struct vki_iovec *)arg2;
for (i = 0; i < (Int)arg3; i++)
- SYSCALL_TRACK( pre_mem_read, tid, "writev(vector[...])",
+ PRE_MEM_READ( "writev(vector[...])",
(Addr)vec[i].iov_base, vec[i].iov_len );
}
}
@@ -5291,21 +5147,19 @@
{
/* int prctl(int option, unsigned long arg2, unsigned long arg3,
unsigned long arg4, unsigned long arg5); */
- MAYBE_PRINTF( "prctl ( %d, %d, %d, %d, %d )\n", arg1, arg2, arg3,
- arg4, arg5 );
+ PRINT( "prctl ( %d, %d, %d, %d, %d )", arg1, arg2, arg3, arg4, arg5 );
}
PRE(adjtimex)
{
struct vki_timex *tx = (struct vki_timex *)arg1;
- MAYBE_PRINTF("adjtimex ( %p )\n", arg1);
+ PRINT("adjtimex ( %p )", arg1);
- SYSCALL_TRACK(pre_mem_read, tid, "adjtimex(timex->modes)", arg1, sizeof(tx->modes));
+ PRE_MEM_READ( "adjtimex(timex->modes)", arg1, sizeof(tx->modes));
#define ADJX(bit,field) \
if (tx->modes & bit) \
- SYSCALL_TRACK(pre_mem_read, tid, \
- "adjtimex(timex->"#field")", \
+ PRE_MEM_READ( "adjtimex(timex->"#field")", \
(Addr)&tx->field, sizeof(tx->field))
ADJX(ADJ_FREQUENCY, freq);
ADJX(ADJ_MAXERROR, maxerror);
@@ -5315,7 +5169,7 @@
ADJX(ADJ_TICK, tick);
#undef ADJX
- SYSCALL_TRACK(pre_mem_write, tid, "adjtimex(timex)", arg1, sizeof(struct vki_timex));
+ PRE_MEM_WRITE( "adjtimex(timex)", arg1, sizeof(struct vki_timex));
}
POST(adjtimex)
@@ -5326,28 +5180,26 @@
PRE(utimes)
{
/* int utimes(const char *filename, struct timeval *tvp); */
- MAYBE_PRINTF("utimes ( %p, %p )\n", arg1,arg2);
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "utimes(filename)", arg1 );
+ PRINT("utimes ( %p, %p )", arg1,arg2);
+ PRE_MEM_RASCIIZ( "utimes(filename)", arg1 );
if (arg2 != (UWord)NULL)
- SYSCALL_TRACK( pre_mem_read, tid, "utimes(tvp)", arg2,
- sizeof(struct vki_timeval) );
+ PRE_MEM_READ( "utimes(tvp)", arg2, sizeof(struct vki_timeval) );
}
PRE(futex)
{
/* int futex(void *futex, int op, int val, const struct timespec *timeout); */
- MAYBE_PRINTF("futex ( %p, %d, %d, %p, %p )\n", arg1,arg2,arg3,arg4,arg5);
- SYSCALL_TRACK( pre_mem_read, tid, "futex(futex)", arg1, sizeof(int) );
+ PRINT("futex ( %p, %d, %d, %p, %p )", arg1,arg2,arg3,arg4,arg5);
+ PRE_MEM_READ( "futex(futex)", arg1, sizeof(int) );
if (arg2 == VKI_FUTEX_WAIT && arg4 != (UWord)NULL)
- SYSCALL_TRACK( pre_mem_read, tid, "futex(timeout)", arg4,
- sizeof(struct vki_timespec) );
+ PRE_MEM_READ( "futex(timeout)", arg4, sizeof(struct vki_timespec) );
if (arg2 == VKI_FUTEX_REQUEUE)
- SYSCALL_TRACK( pre_mem_read, tid, "futex(futex2)", arg4, sizeof(int) );
+ PRE_MEM_READ( "futex(futex2)", arg4, sizeof(int) );
}
POST(futex)
{
- VG_TRACK( post_mem_write, arg1, sizeof(int) );
+ POST_MEM_WRITE( arg1, sizeof(int) );
if (arg2 == VKI_FUTEX_FD) {
if (!fd_allowed(res, "futex", tid, True)) {
VG_(close)(res);
@@ -5362,15 +5214,15 @@
PRE(sched_setaffinity)
{
/* int sched_setaffinity(pid_t pid, unsigned int len, unsigned long *mask) */
- MAYBE_PRINTF("sched_setaffinity ( %d, %d, %p )\n", arg1, arg2, arg3);
- SYSCALL_TRACK(pre_mem_read, tid, "sched_setaffinity(mask)", arg3, arg2);
+ PRINT("sched_setaffinity ( %d, %d, %p )", arg1, arg2, arg3);
+ PRE_MEM_READ( "sched_setaffinity(mask)", arg3, arg2);
}
PRE(sched_getaffinity)
{
/* int sched_setaffinity(pid_t pid, unsigned int len, unsigned long *mask) */
- MAYBE_PRINTF("sched_getaffinity ( %d, %d, %p )\n", arg1, arg2, arg3);
- SYSCALL_TRACK(pre_mem_write, tid, "sched_getaffinity(mask)", arg3, arg2);
+ PRINT("sched_getaffinity ( %d, %d, %p )", arg1, arg2, arg3);
+ PRE_MEM_WRITE( "sched_getaffinity(mask)", arg3, arg2);
}
POST(sched_getaffinity)
@@ -5381,8 +5233,8 @@
PRE(acct)
{
/* int acct(const char *filename); */
- MAYBE_PRINTF("acct ( %p )\n", arg1);
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "acct(filename)", arg1 );
+ PRINT("acct ( %p )", arg1);
+ PRE_MEM_RASCIIZ( "acct(filename)", arg1 );
}
#define SIGNAL_SIMULATION 1
@@ -5390,17 +5242,16 @@
PRE(pause)
{
/* int pause(void); */
- MAYBE_PRINTF("pause ( )\n");
+ PRINT("pause ( )");
}
PRE(rt_sigsuspend)
{
/* int sigsuspend(const sigset_t *mask); */
- MAYBE_PRINTF("sigsuspend ( %p )\n", arg1 );
+ PRINT("sigsuspend ( %p )", arg1 );
if (arg1 != (Addr)NULL) {
/* above NULL test is paranoia */
- SYSCALL_TRACK( pre_mem_read, tid, "sigsuspend(mask)", arg1,
- sizeof(vki_sigset_t) );
+ PRE_MEM_READ( "sigsuspend(mask)", arg1, sizeof(vki_sigset_t) );
}
}
@@ -5410,28 +5261,25 @@
{
/* int sigtimedwait(const sigset_t *set, siginfo_t *info,
const struct timespec timeout); */
- MAYBE_PRINTF("sigtimedwait ( %p, %p, timeout )\n", arg1, arg2);
+ PRINT("sigtimedwait ( %p, %p, timeout )", arg1, arg2);
if (arg1 != (UWord)NULL)
- SYSCALL_TRACK( pre_mem_read, tid, "sigtimedwait(set)", arg1,
- sizeof(vki_sigset_t));
+ PRE_MEM_READ( "sigtimedwait(set)", arg1, sizeof(vki_sigset_t));
if (arg2 != (UWord)NULL)
- SYSCALL_TRACK( pre_mem_write, tid, "sigtimedwait(info)", arg2,
- sizeof(vki_siginfo_t) );
+ PRE_MEM_WRITE( "sigtimedwait(info)", arg2, sizeof(vki_siginfo_t) );
}
POST(rt_sigtimedwait)
{
if (arg2 != (UWord)NULL)
- VG_TRACK( post_mem_write, arg2, sizeof(vki_siginfo_t) );
+ POST_MEM_WRITE( arg2, sizeof(vki_siginfo_t) );
}
PRE(rt_sigqueueinfo)
{
/* long sys_rt_sigqueueinfo(int pid, int sig, siginfo_t *uinfo) */
- MAYBE_PRINTF("rt_sigqueueinfo(%d, %d, %p)\n", arg1, arg2, arg3);
+ PRINT("rt_sigqueueinfo(%d, %d, %p)", arg1, arg2, arg3);
if (arg2 != (UWord)NULL)
- SYSCALL_TRACK( pre_mem_read, tid, "sigqueueinfo(uinfo)", arg3,
- sizeof(vki_siginfo_t) );
+ PRE_MEM_READ( "sigqueueinfo(uinfo)", arg3, sizeof(vki_siginfo_t) );
}
POST(rt_sigqueueinfo)
@@ -5448,14 +5296,12 @@
PRE(sigaltstack)
{
/* int sigaltstack(const stack_t *ss, stack_t *oss); */
- MAYBE_PRINTF("sigaltstack ( %p, %p )\n",arg1,arg2);
+ PRINT("sigaltstack ( %p, %p )",arg1,arg2);
if (arg1 != (UWord)NULL) {
- SYSCALL_TRACK( pre_mem_read, tid, "sigaltstack(ss)",
- arg1, sizeof(vki_stack_t) );
+ PRE_MEM_READ( "sigaltstack(ss)", arg1, sizeof(vki_stack_t) );
}
if (arg2 != (UWord)NULL) {
- SYSCALL_TRACK( pre_mem_write, tid, "sigaltstack(oss)",
- arg2, sizeof(vki_stack_t) );
+ PRE_MEM_WRITE( "sigaltstack(oss)", arg2, sizeof(vki_stack_t) );
}
if (SIGNAL_SIMULATION)
@@ -5465,20 +5311,18 @@
POST(sigaltstack)
{
if (res == 0 && arg2 != (UWord)NULL)
- VG_TRACK( post_mem_write, arg2, sizeof(vki_stack_t));
+ POST_MEM_WRITE( arg2, sizeof(vki_stack_t));
}
PRE(sigaction)
{
/* int sigaction(int signum, struct k_sigaction *act,
struct k_sigaction *oldact); */
- MAYBE_PRINTF("sigaction ( %d, %p, %p )\n",arg1,arg2,arg3);
+ PRINT("sigaction ( %d, %p, %p )",arg1,arg2,arg3);
if (arg2 != (UWord)NULL)
- SYSCALL_TRACK( pre_mem_read, tid, "sigaction(act)",
- arg2, sizeof(struct vki_sigaction));
+ PRE_MEM_READ( "sigaction(act)", arg2, sizeof(struct vki_sigaction));
if (arg3 != (UWord)NULL)
- SYSCALL_TRACK( pre_mem_write, tid, "sigaction(oldact)",
- arg3, sizeof(struct vki_sigaction));
+ PRE_MEM_WRITE( "sigaction(oldact)", arg3, sizeof(struct vki_sigaction));
if (SIGNAL_SIMULATION)
VG_(do__NR_sigaction)(tid);
@@ -5487,7 +5331,7 @@
POST(sigaction)
{
if (res == 0 && arg3 != (UWord)NULL)
- VG_TRACK( post_mem_write, arg3, sizeof(struct vki_sigaction));
+ POST_MEM_WRITE( arg3, sizeof(struct vki_sigaction));
}
PREALIAS(rt_sigaction, sigaction);
@@ -5497,13 +5341,11 @@
{
/* int sigprocmask(int how, k_sigset_t *set,
k_sigset_t *oldset); */
- MAYBE_PRINTF("sigprocmask ( %d, %p, %p )\n",arg1,arg2,arg3);
+ PRINT("sigprocmask ( %d, %p, %p )",arg1,arg2,arg3);
if (arg2 != (UWord)NULL)
- SYSCALL_TRACK( pre_mem_read, tid, "sigprocmask(set)",
- arg2, sizeof(vki_sigset_t));
+ PRE_MEM_READ( "sigprocmask(set)", arg2, sizeof(vki_sigset_t));
if (arg3 != (UWord)NULL)
- SYSCALL_TRACK( pre_mem_write, tid, "sigprocmask(oldset)",
- arg3, sizeof(vki_sigset_t));
+ PRE_MEM_WRITE( "sigprocmask(oldset)", arg3, sizeof(vki_sigset_t));
if (SIGNAL_SIMULATION)
VG_(do__NR_sigprocmask) ( tid,
@@ -5515,7 +5357,7 @@
POST(sigprocmask)
{
if (res == 0 && arg3 != (UWord)NULL)
- VG_TRACK( post_mem_write, arg3, sizeof(vki_sigset_t));
+ POST_MEM_WRITE( arg3, sizeof(vki_sigset_t));
}
PREALIAS(rt_sigprocmask, sigprocmask);
@@ -5524,14 +5366,13 @@
PRE(sigpending)
{
/* int sigpending( sigset_t *set ) ; */
- MAYBE_PRINTF( "sigpending ( %p )\n", arg1 );
- SYSCALL_TRACK( pre_mem_write, tid, "sigpending(set)",
- arg1, sizeof(vki_sigset_t));
+ PRINT( "sigpending ( %p )", arg1 );
+ PRE_MEM_WRITE( "sigpending(set)", arg1, sizeof(vki_sigset_t));
}
POST(sigpending)
{
- VG_TRACK( post_mem_write, arg1, sizeof( vki_sigset_t ) ) ;
+ POST_MEM_WRITE( arg1, sizeof( vki_sigset_t ) ) ;
}
PREALIAS(rt_sigpending, sigpending);
@@ -5543,9 +5384,8 @@
Addr addr;
/* long io_setup (unsigned nr_events, aio_context_t *ctxp); */
- MAYBE_PRINTF("io_setup ( %ul, %p )\n",arg1,arg2);
- SYSCALL_TRACK( pre_mem_write, tid, "io_setup(ctxp)",
- arg2, sizeof(vki_aio_context_t) );
+ PRINT("io_setup ( %ul, %p )",arg1,arg2);
+ PRE_MEM_WRITE( "io_setup(ctxp)", arg2, sizeof(vki_aio_context_t) );
size = PGROUNDUP(sizeof(struct vki_aio_ring) + arg1 * sizeof(struct vki_io_event));
addr = VG_(find_map_space)(0, size, True);
@@ -5562,7 +5402,7 @@
vg_assert(valid_client_addr(addr, size, tid, "io_setup"));
VG_TRACK( new_mem_mmap, addr, size, True, True, False );
- VG_TRACK( post_mem_write, arg2, sizeof(vki_aio_context_t) );
+ POST_MEM_WRITE( arg2, sizeof(vki_aio_context_t) );
}
else {
VG_(unmap_range)(addr, size);
@@ -5576,7 +5416,7 @@
SizeT size = PGROUNDUP(sizeof(struct vki_aio_ring) + r->nr * sizeof(struct vki_io_event));
/* long io_destroy (aio_context_t ctx); */
- MAYBE_PRINTF("io_destroy ( %ul )\n",arg1);
+ PRINT("io_destroy ( %ul )",arg1);
set_result( VG_(do_syscall)(SYSNO, arg1) );
@@ -5590,12 +5430,12 @@
{
/* long io_getevents (aio_context_t ctx_id, long min_nr, long nr,
struct io_event *events, struct timespec *timeout); */
- MAYBE_PRINTF("io_getevents ( %ul, %l, %l, %p, %p )\n",arg1,arg2,arg3,arg4,arg5);
+ PRINT("io_getevents ( %ul, %l, %l, %p, %p )",arg1,arg2,arg3,arg4,arg5);
if (arg3 > 0)
- SYSCALL_TRACK( pre_mem_write, tid, "io_getevents(events)",
+ PRE_MEM_WRITE( "io_getevents(events)",
arg4, sizeof(struct vki_io_event)*arg3 );
if (arg5 != (UWord)NULL)
- SYSCALL_TRACK( pre_mem_read, tid, "io_getevents(timeout)",
+ PRE_MEM_READ( "io_getevents(timeout)",
arg5, sizeof(struct vki_timespec));
}
@@ -5604,7 +5444,7 @@
int i;
if (res > 0) {
- VG_TRACK( post_mem_write, arg4, sizeof(struct vki_io_event)*res );
+ POST_MEM_WRITE( arg4, sizeof(struct vki_io_event)*res );
for (i = 0; i < res; i++) {
const struct vki_io_event *vev = ((struct vki_io_event *)arg4) + i;
const struct vki_iocb *cb = (struct vki_iocb *)(Addr)vev->obj;
@@ -5612,7 +5452,7 @@
switch (cb->aio_lio_opcode) {
case VKI_IOCB_CMD_PREAD:
if (vev->result > 0)
- VG_TRACK( post_mem_write, cb->aio_buf, vev->result );
+ POST_MEM_WRITE( cb->aio_buf, vev->result );
break;
case VKI_IOCB_CMD_PWRITE:
@@ -5631,22 +5471,19 @@
int i;
/* long io_submit (aio_context_t ctx_id, long nr, struct iocb **iocbpp); */
- MAYBE_PRINTF("io_submit( %ul, %l, %p )\n",arg1,arg2,arg3);
- SYSCALL_TRACK( pre_mem_read, tid, "io_submit(iocbpp)",
- arg3, sizeof(struct vki_iocb *)*arg2 );
+ PRINT("io_submit( %ul, %l, %p )",arg1,arg2,arg3);
+ PRE_MEM_READ( "io_submit(iocbpp)", arg3, sizeof(struct vki_iocb *)*arg2 );
for (i = 0; i < arg2; i++) {
struct vki_iocb *cb = ((struct vki_iocb **)arg3)[i];
- SYSCALL_TRACK( pre_mem_read, tid, "io_submit(iocb)",
+ PRE_MEM_READ( "io_submit(iocb)",
(Addr)cb, sizeof(struct vki_iocb) );
switch (cb->aio_lio_opcode) {
case VKI_IOCB_CMD_PREAD:
- SYSCALL_TRACK( pre_mem_write, tid, "io_submit(PREAD)",
- cb->aio_buf, cb->aio_nbytes );
+ PRE_MEM_WRITE( "io_submit(PREAD)", cb->aio_buf, cb->aio_nbytes );
break;
case VKI_IOCB_CMD_PWRITE:
- SYSCALL_TRACK( pre_mem_read, tid, "io_submit(PWRITE)",
- cb->aio_buf, cb->aio_nbytes );
+ PRE_MEM_READ( "io_submit(PWRITE)", cb->aio_buf, cb->aio_nbytes );
break;
default:
@@ -5660,28 +5497,26 @@
{
/* long io_cancel (aio_context_t ctx_id, struct iocb *iocb,
struct io_event *result); */
- MAYBE_PRINTF("io_cancel( %ul, %p, %p )\n",arg1,arg2,arg3);
- SYSCALL_TRACK( pre_mem_read, tid, "io_cancel(iocb)",
- arg2, sizeof(struct vki_iocb) );
- SYSCALL_TRACK( pre_mem_write, tid, "io_cancel(result)",
- arg3, sizeof(struct vki_io_event) );
+ PRINT("io_cancel( %ul, %p, %p )",arg1,arg2,arg3);
+ PRE_MEM_READ( "io_cancel(iocb)", arg2, sizeof(struct vki_iocb) );
+ PRE_MEM_WRITE( "io_cancel(result)", arg3, sizeof(struct vki_io_event) );
}
POST(io_cancel)
{
- VG_TRACK( post_mem_write, arg3, sizeof(struct vki_io_event) );
+ POST_MEM_WRITE( arg3, sizeof(struct vki_io_event) );
}
PRE(mq_open)
{
/* mqd_t mq_open(const char *name, int oflag, ...); */
- MAYBE_PRINTF("mq_open( %p(%s), %d )\n", arg1,arg1,arg2);
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "mq_open(name)", arg1 );
+ PRINT("mq_open( %p(%s), %d )", arg1,arg1,arg2);
+ PRE_MEM_RASCIIZ( "mq_open(name)", arg1 );
if ((arg2 & VKI_O_CREAT) != 0 && arg4 != 0) {
const struct vki_mq_attr *attr = (struct vki_mq_attr *)arg4;
- SYSCALL_TRACK( pre_mem_read, tid, "mq_open(attr->mq_maxmsg)",
+ PRE_MEM_READ( "mq_open(attr->mq_maxmsg)",
(Addr)&attr->mq_maxmsg, sizeof(attr->mq_maxmsg) );
- SYSCALL_TRACK( pre_mem_read, tid, "mq_open(attr->mq_msgsize)",
+ PRE_MEM_READ( "mq_open(attr->mq_msgsize)",
(Addr)&attr->mq_msgsize, sizeof(attr->mq_msgsize) );
}
}
@@ -5695,28 +5530,28 @@
if (VG_(clo_track_fds))
record_fd_open(tid, res, VG_(arena_strdup)(VG_AR_CORE, (Char*)arg1));
}
- MAYBE_PRINTF("%d\n",res);
+ PRINT("%d\n",res);
}
PRE(mq_unlink)
{
/* int mq_unlink(const char *name) */
- MAYBE_PRINTF("mq_unlink ( %p(%s) )\n",arg1, arg1);
- SYSCALL_TRACK( pre_mem_read_asciiz, tid, "mq_unlink(name)", arg1 );
+ PRINT("mq_unlink ( %p(%s) )",arg1, arg1);
+ PRE_MEM_RASCIIZ( "mq_unlink(name)", arg1 );
}
PRE(mq_timedsend)
{
/* int mq_timedsend(mqd_t mqdes, const char *msg_ptr, size_t msg_len,
unsigned msg_prio, const struct timespec *abs_timeout); */
- MAYBE_PRINTF("mq_timedsend ( %d, %p, %llu, %d, %p )\n",
+ PRINT("mq_timedsend ( %d, %p, %llu, %d, %p )",
arg1,arg2,(ULong)arg3,arg4,arg5);
if (!fd_allowed(arg1, "mq_timedsend", tid, False)) {
set_result( -VKI_EBADF );
} else {
- SYSCALL_TRACK( pre_mem_read, tid, "mq_timedsend(msg_ptr)", arg2, arg3 );
+ PRE_MEM_READ( "mq_timedsend(msg_ptr)", arg2, arg3 );
if (arg5 != 0)
- SYSCALL_TRACK( pre_mem_read, tid, "mq_timedsend(abs_timeout)", arg5,
+ PRE_MEM_READ( "mq_timedsend(abs_timeout)", arg5,
sizeof(struct vki_timespec) );
}
}
@@ -5726,54 +5561,53 @@
/* ssize_t mq_timedreceive(mqd_t mqdes, char *restrict msg_ptr,
size_t msg_len, unsigned *restrict msg_prio,
const struct timespec *restrict abs_timeout); */
- MAYBE_PRINTF("mq_timedreceive( %d, %p, %llu, %p, %p )\n",
+ PRINT("mq_timedreceive( %d, %p, %llu, %p, %p )",
arg1,arg2,(ULong)arg3,arg4,arg5);
if (!fd_allowed(arg1, "mq_timedreceive", tid, False)) {
set_result( -VKI_EBADF );
} else {
- SYSCALL_TRACK( pre_mem_write, tid, "mq_timedreceive(msg_ptr)", arg2, arg3 );
+ PRE_MEM_WRITE( "mq_timedreceive(msg_ptr)", arg2, arg3 );
if (arg4 != 0)
- SYSCALL_TRACK( pre_mem_write, tid, "mq_timedreceive(msg_prio)",
+ PRE_MEM_WRITE( "mq_timedreceive(msg_prio)",
arg4, sizeof(unsigned int) );
if (arg5 != 0)
- SYSCALL_TRACK( pre_mem_read, tid, "mq_timedreceive(abs_timeout)",
+ PRE_MEM_READ( "mq_timedreceive(abs_timeout)",
arg5, sizeof(struct vki_timespec) );
}
}
POST(mq_timedreceive)
{
- VG_TRACK( post_mem_write, arg2, arg3 );
+ POST_MEM_WRITE( arg2, arg3 );
if (arg4 != 0)
- VG_TRACK( post_mem_write, arg4, sizeof(unsigned int) );
+ POST_MEM_WRITE( arg4, sizeof(unsigned int) );
}
PRE(mq_notify)
{
/* int mq_notify(mqd_t mqdes, const struct sigevent *notification); */
- MAYBE_PRINTF("mq_notify( %d, %p )\n", arg1,arg2 );
+ PRINT("mq_notify( %d, %p )", arg1,arg2 );
if (!fd_allowed(arg1, "mq_notify", tid, False))
set_result( -VKI_EBADF );
else if (arg2 != 0)
- SYSCALL_TRACK( pre_mem_read, tid, "mq_notify", arg2,
- sizeof(struct vki_sigevent) );
+ PRE_MEM_READ( "mq_notify", arg2, sizeof(struct vki_sigevent) );
}
PRE(mq_getsetattr)
{
/* int mq_getsetattr(mqd_t mqdes, const struct mq_attr *restrict mqstat,
struct mq_attr *restrict omqstat); */
- MAYBE_PRINTF("mq_getsetattr( %d, %p, %p )\n", arg1,arg2,arg3 );
+ PRINT("mq_getsetattr( %d, %p, %p )", arg1,arg2,arg3 );
if (!fd_allowed(arg1, "mq_getsetattr", tid, False)) {
set_result( -VKI_EBADF );
} else {
if (arg2 != 0) {
const struct vki_mq_attr *attr = (struct vki_mq_attr *)arg2;
- SYSCALL_TRACK( pre_mem_read, tid, "mq_getsetattr(mqstat->mq_flags)",
+ PRE_MEM_READ( "mq_getsetattr(mqstat->mq_flags)",
(Addr)&attr->mq_flags, sizeof(attr->mq_flags) );
}
if (arg3 != 0)
- SYSCALL_TRACK( pre_mem_write, tid, "mq_getsetattr(omqstat)", arg3,
+ PRE_MEM_WRITE( "mq_getsetattr(omqstat)", arg3,
sizeof(struct vki_mq_attr) );
}
}
@@ -5781,24 +5615,22 @@
POST(mq_getsetattr)
{
if (arg3 != 0)
- VG_TRACK( post_mem_write, arg3, sizeof(struct vki_mq_attr) );
+ POST_MEM_WRITE( arg3, sizeof(struct vki_mq_attr) );
}
PRE(timer_create)
{
/* int timer_create(clockid_t clock_id, struct sigevent *restrict evp,
timer_t *restrict timerid); */
- MAYBE_PRINTF("timer_create( %d, %p, %p )\n", arg1,arg2,arg3);
+ PRINT("timer_create( %d, %p, %p )", arg1,arg2,arg3);
if (arg2 != 0)
- SYSCALL_TRACK( pre_mem_read, tid, "timer_create(evp)", arg2,
- sizeof(struct vki_sigevent) );
- SYSCALL_TRACK( pre_mem_write, tid, "timer_create(timerid)", arg3,
- sizeof(vki_timer_t) );
+ PRE_MEM_READ( "timer_create(evp)", arg2, sizeof(struct vki_sigevent) );
+ PRE_MEM_WRITE( "timer_create(timerid)", arg3, sizeof(vki_timer_t) );
}
POST(timer_create)
{
- VG_TRACK( post_mem_write, arg3, sizeof(vki_timer_t) );
+ POST_MEM_WRITE( arg3, sizeof(vki_timer_t) );
}
PRE(timer_settime)
@@ -5806,77 +5638,74 @@
/* int timer_settime(timer_t timerid, int flags,
const struct itimerspec *restrict value,
struct itimerspec *restrict ovalue); */
- MAYBE_PRINTF("timer_settime( %p, %d, %p, %p )\n", arg1,arg2,arg3,arg4);
- SYSCALL_TRACK( pre_mem_read, tid, "timer_settime(value)", arg3,
+ PRINT("timer_settime( %p, %d, %p, %p )", arg1,arg2,arg3,arg4);
+ PRE_MEM_READ( "timer_settime(value)", arg3,
sizeof(struct vki_itimerspec) );
if (arg4 != 0)
- SYSCALL_TRACK( pre_mem_write, tid, "timer_settime(ovalue)", arg4,
+ PRE_MEM_WRITE( "timer_settime(ovalue)", arg4,
sizeof(struct vki_itimerspec) );
}
POST(timer_settime)
{
if (arg4 != 0)
- VG_TRACK( post_mem_write, arg4, sizeof(struct vki_itimerspec) );
+ POST_MEM_WRITE( arg4, sizeof(struct vki_itimerspec) );
}
PRE(timer_gettime)
{
/* int timer_gettime(timer_t timerid, struct itimerspec *value); */
- MAYBE_PRINTF("timer_gettime( %p, %p )\n", arg1,arg2);
- SYSCALL_TRACK( pre_mem_write, tid, "timer_gettime(value)", arg2,
+ PRINT("timer_gettime( %p, %p )", arg1,arg2);
+ PRE_MEM_WRITE( "timer_gettime(value)", arg2,
sizeof(struct vki_itimerspec));
}
POST(timer_gettime)
{
- VG_TRACK( post_mem_write, arg2, sizeof(struct vki_itimerspec) );
+ POST_MEM_WRITE( arg2, sizeof(struct vki_itimerspec) );
}
PRE(timer_getoverrun)
{
/* int timer_getoverrun(timer_t timerid); */
- MAYBE_PRINTF("timer_getoverrun( %p )\n", arg1);
+ PRINT("timer_getoverrun( %p )", arg1);
}
PRE(timer_delete)
{
/* int timer_delete(timer_t timerid); */
- MAYBE_PRINTF("timer_delete( %p )\n", arg1);
+ PRINT("timer_delete( %p )", arg1);
}
PRE(clock_settime)
{
/* int clock_settime(clockid_t clk_id, const struct timespec *tp); */
- MAYBE_PRINTF("clock_settime( %d, %p )\n", arg1,arg2);
- SYSCALL_TRACK(pre_mem_read, tid, "clock_gettime(tp)",
- arg2, sizeof(struct vki_timespec) );
+ PRINT("clock_settime( %d, %p )", arg1,arg2);
+ PRE_MEM_READ( "clock_gettime(tp)", arg2, sizeof(struct vki_timespec) );
}
PRE(clock_gettime)
{
/* int clock_gettime(clockid_t clk_id, struct timespec *tp); */
- MAYBE_PRINTF("clock_gettime( %d, %p )\n" , arg1,arg2);
- SYSCALL_TRACK(pre_mem_write, tid, "clock_gettime(tp)",
- arg2, sizeof(struct vki_timespec) );
+ PRINT("clock_gettime( %d, %p )" , arg1,arg2);
+ PRE_MEM_WRITE( "clock_gettime(tp)", arg2, sizeof(struct vki_timespec) );
}
POST(clock_gettime)
{
- VG_TRACK( post_mem_write, arg2, sizeof(struct vki_timespec) );
+ POST_MEM_WRITE( arg2, sizeof(struct vki_timespec) );
}
PRE(clock_getres)
{
/* int clock_getres(clockid_t clk_id, struct timespec *res); */
- MAYBE_PRINTF("clock_getres( %d, %p )\n" , arg1,arg2);
- SYSCALL_TRACK(pre_mem_write, tid, "clock_getres(res)",
- arg2, sizeof(struct vki_timespec) );
+ PRINT("clock_getres( %d, %p )" , arg1,arg2);
+ PRE_MEM_WRITE( "clock_getres(res)", arg2, sizeof(struct vki_timespec) );
}
POST(clock_getres)
{
- VG_TRACK( post_mem_write, arg2, sizeof(struct vki_timespec) );
+ POST_MEM_WRITE( arg2, sizeof(struct vki_timespec) );
}
struct sys_info {
@@ -6240,10 +6069,10 @@
VGP_POPCC(VgpSkinSysWrap);
}
- MAYBE_PRINTF("SYSCALL[%d,%d](%3d)%s%s:",
- VG_(getpid)(), tid, syscallno,
- special ? " special" : "",
- (sys->flags & MayBlock) != 0 ? " blocking" : "");
+ PRINT("SYSCALL[%d,%d](%3d)%s%s:",
+ VG_(getpid)(), tid, syscallno,
+ special ? " special" : "",
+ (sys->flags & MayBlock) != 0 ? " blocking" : "");
if (special) {
/* "Special" syscalls are implemented by Valgrind internally,
@@ -6257,6 +6086,7 @@
vg_assert(tst->sys_flags == sys->flags);
+ PRINT(" --> %lld (0x%llx)\n", (Long)(Word)res, (ULong)res);
syscall_done = True;
} else {
(sys->before)(tst->tid, tst);
@@ -6264,16 +6094,19 @@
if ((Word)res <= 0) {
/* "before" decided the syscall wasn't viable, so don't do
anything - just pretend the syscall happened. */
+ PRINT(" ==> %lld (0x%llx)\n", (Long)(Word)res, (ULong)res);
syscall_done = True;
} else if ((tst->sys_flags & MayBlock) != 0) {
/* Issue to worker. If we're waiting on the syscall because
it's in the hands of the ProxyLWP, then set the thread
state to WaitSys. */
+ PRINT(" --> ...\n");
tst->status = VgTs_WaitSys;
VG_(sys_issue)(tid);
} else {
/* run the syscall directly */
res = VG_(do_syscall)(syscallno, arg1, arg2, arg3, arg4, arg5, arg6);
+ PRINT(" --> %lld (0x%llx)\n", (Long)(Word)res, (ULong)res);
syscall_done = True;
}
}
@@ -6311,6 +6144,7 @@
VGP_PUSHCC(VgpCoreSysWrap);
tst = VG_(get_ThreadState)(tid);
+ vg_assert(tst->tid == tid);
/* Tell the tool about the syscall return value */
SET_SYSCALL_RETVAL(tst->tid, res);
diff --git a/coregrind/x86-linux/core_platform.h b/coregrind/x86-linux/core_platform.h
index 0726110..3ca000a 100644
--- a/coregrind/x86-linux/core_platform.h
+++ b/coregrind/x86-linux/core_platform.h
@@ -110,7 +110,7 @@
#define PLATFORM_GET_MMAP_ARGS(tst, a1, a2, a3, a4, a5, a6) do {\
UInt *arg_block = (UInt*)PLATFORM_SYSCALL_ARG1(tst->arch); \
- SYSCALL_TRACK( pre_mem_read, tst->tid, "mmap(args)", arg1, 6*sizeof(UWord) ); \
+ PRE_MEM_READ( "mmap(args)", arg1, 6*sizeof(UWord) ); \
a1 = arg_block[0]; \
a2 = arg_block[1]; \
a3 = arg_block[2]; \