|
From: Nicholas N. <nj...@ca...> - 2004-11-16 17:32:05
|
CVS commit by nethercote:
Cleanups: removing stuff no longer needed now that all syscalls have been
converted.
M +330 -354 vg_syscalls.c 1.218
--- valgrind/coregrind/vg_syscalls.c #1.217:1.218
@@ -1085,11 +1085,8 @@ static Bool fd_allowed(Int fd, const Cha
#define PostOnFail (1 << 3)
-#define PRE(x) static void before___NR_##x(ThreadId tid, ThreadState *tst)
-#define POST(x) static void after___NR_##x(ThreadId tid, ThreadState *tst)
-
-#define PREx(x,f) \
+#define PRE(x,f) \
static UInt flags_##x = f; \
static void before_##x(ThreadId tid, ThreadState *tst)
-#define POSTx(x) \
+#define POST(x) \
static void after_##x(ThreadId tid, ThreadState *tst)
@@ -1112,20 +1109,20 @@ static Bool fd_allowed(Int fd, const Cha
#define LOHI64(lo,hi) ( (lo) | ((ULong)(hi) << 32) )
-PREx(sys_exit_group, Special)
+PRE(sys_exit_group, Special)
{
VG_(core_panic)("syscall exit_group() not caught by the scheduler?!");
}
-PREx(sys_exit, Special)
+PRE(sys_exit, Special)
{
VG_(core_panic)("syscall exit() not caught by the scheduler?!");
}
-PREx(sys_sched_yield, Special)
+PRE(sys_sched_yield, Special)
{
VG_(core_panic)("syscall sched_yield() not caught by the scheduler?!");
}
-PREx(sys_ni_syscall, Special)
+PRE(sys_ni_syscall, Special)
{
PRINT("non-existent syscall! (ni_syscall)");
@@ -1136,5 +1133,5 @@ PREx(sys_ni_syscall, Special)
// XXX: I think this is x86/linux-specific
// XXX: Why is the memory pointed to by arg3 never checked?
-PREx(sys_ptrace, 0)
+PRE(sys_ptrace, 0)
{
PRINT("sys_ptrace ( %d, %d, %p, %p )", arg1,arg2,arg3,arg4);
@@ -1176,5 +1173,5 @@ PREx(sys_ptrace, 0)
// XXX: I think this is x86/linux-specific
-POSTx(sys_ptrace)
+POST(sys_ptrace)
{
switch (arg1) {
@@ -1196,5 +1193,5 @@ POSTx(sys_ptrace)
}
-PREx(sys_mount, MayBlock)
+PRE(sys_mount, MayBlock)
{
// Nb: depending on 'flags', the 'type' and 'data' args may be ignored.
@@ -1210,5 +1207,5 @@ PREx(sys_mount, MayBlock)
}
-PREx(sys_oldumount, 0)
+PRE(sys_oldumount, 0)
{
PRINT("sys_oldumount( %p )", arg1);
@@ -1217,5 +1214,5 @@ PREx(sys_oldumount, 0)
}
-PREx(sys_umount, 0)
+PRE(sys_umount, 0)
{
PRINT("sys_umount( %p )", arg1);
@@ -1224,5 +1221,5 @@ PREx(sys_umount, 0)
}
-PREx(sys_modify_ldt, Special)
+PRE(sys_modify_ldt, Special)
{
PRINT("sys_modify_ldt ( %d, %p, %d )", arg1,arg2,arg3);
@@ -1246,5 +1243,5 @@ PREx(sys_modify_ldt, Special)
}
-PREx(sys_set_thread_area, Special)
+PRE(sys_set_thread_area, Special)
{
PRINT("sys_set_thread_area ( %p )", arg1);
@@ -1256,5 +1253,5 @@ PREx(sys_set_thread_area, Special)
}
-PREx(sys_get_thread_area, Special)
+PRE(sys_get_thread_area, Special)
{
PRINT("sys_get_thread_area ( %p )", arg1);
@@ -1270,5 +1267,5 @@ PREx(sys_get_thread_area, Special)
}
-PREx(sys_set_tid_address, Special)
+PRE(sys_set_tid_address, Special)
{
PRINT("sys_set_tid_address ( %p )", arg1);
@@ -1276,5 +1273,5 @@ PREx(sys_set_tid_address, Special)
}
-PREx(sys_setresgid16, 0)
+PRE(sys_setresgid16, 0)
{
PRINT("sys_setresgid16 ( %d, %d, %d )", arg1, arg2, arg3);
@@ -1283,5 +1280,5 @@ PREx(sys_setresgid16, 0)
}
-PREx(sys_setresgid, 0)
+PRE(sys_setresgid, 0)
{
PRINT("sys_setresgid ( %d, %d, %d )", arg1, arg2, arg3);
@@ -1290,5 +1287,5 @@ PREx(sys_setresgid, 0)
}
-PREx(sys_vhangup, 0)
+PRE(sys_vhangup, 0)
{
PRINT("sys_vhangup ( )");
@@ -1296,5 +1293,5 @@ PREx(sys_vhangup, 0)
}
-PREx(sys_iopl, 0)
+PRE(sys_iopl, 0)
{
PRINT("sys_iopl ( %d )", arg1);
@@ -1302,5 +1299,5 @@ PREx(sys_iopl, 0)
}
-PREx(sys_setxattr, MayBlock)
+PRE(sys_setxattr, MayBlock)
{
PRINT("sys_setxattr ( %p, %p, %p, %llu, %d )",
@@ -1314,5 +1311,5 @@ PREx(sys_setxattr, MayBlock)
}
-PREx(sys_lsetxattr, MayBlock)
+PRE(sys_lsetxattr, MayBlock)
{
PRINT("sys_lsetxattr ( %p, %p, %p, %llu, %d )",
@@ -1326,5 +1323,5 @@ PREx(sys_lsetxattr, MayBlock)
}
-PREx(sys_fsetxattr, MayBlock)
+PRE(sys_fsetxattr, MayBlock)
{
PRINT("sys_fsetxattr ( %d, %p, %p, %llu, %d )",
@@ -1337,5 +1334,5 @@ PREx(sys_fsetxattr, MayBlock)
}
-PREx(sys_getxattr, MayBlock)
+PRE(sys_getxattr, MayBlock)
{
PRINT("sys_getxattr ( %p, %p, %p, %llu )", arg1,arg2,arg3, (ULong)arg4);
@@ -1347,5 +1344,5 @@ PREx(sys_getxattr, MayBlock)
}
-POSTx(sys_getxattr)
+POST(sys_getxattr)
{
if (res > 0 && arg3 != (Addr)NULL) {
@@ -1354,5 +1351,5 @@ POSTx(sys_getxattr)
}
-PREx(sys_lgetxattr, MayBlock)
+PRE(sys_lgetxattr, MayBlock)
{
PRINT("sys_lgetxattr ( %p, %p, %p, %llu )", arg1,arg2,arg3, (ULong)arg4);
@@ -1364,5 +1361,5 @@ PREx(sys_lgetxattr, MayBlock)
}
-POSTx(sys_lgetxattr)
+POST(sys_lgetxattr)
{
if (res > 0 && arg3 != (Addr)NULL) {
@@ -1371,5 +1368,5 @@ POSTx(sys_lgetxattr)
}
-PREx(sys_fgetxattr, MayBlock)
+PRE(sys_fgetxattr, MayBlock)
{
PRINT("sys_fgetxattr ( %d, %p, %p, %llu )", arg1, arg2, arg3, (ULong)arg4);
@@ -1380,5 +1377,5 @@ PREx(sys_fgetxattr, MayBlock)
}
-POSTx(sys_fgetxattr)
+POST(sys_fgetxattr)
{
if (res > 0 && arg3 != (Addr)NULL)
@@ -1386,5 +1383,5 @@ POSTx(sys_fgetxattr)
}
-PREx(sys_listxattr, MayBlock)
+PRE(sys_listxattr, MayBlock)
{
PRINT("sys_listxattr ( %p, %p, %llu )", arg1, arg2, (ULong)arg3);
@@ -1395,5 +1392,5 @@ PREx(sys_listxattr, MayBlock)
}
-POSTx(sys_listxattr)
+POST(sys_listxattr)
{
if (res > 0 && arg2 != (Addr)NULL)
@@ -1401,5 +1398,5 @@ POSTx(sys_listxattr)
}
-PREx(sys_llistxattr, MayBlock)
+PRE(sys_llistxattr, MayBlock)
{
PRINT("sys_llistxattr ( %p, %p, %llu )", arg1, arg2, (ULong)arg3);
@@ -1410,5 +1407,5 @@ PREx(sys_llistxattr, MayBlock)
}
-POSTx(sys_llistxattr)
+POST(sys_llistxattr)
{
if (res > 0 && arg2 != (Addr)NULL)
@@ -1416,5 +1413,5 @@ POSTx(sys_llistxattr)
}
-PREx(sys_flistxattr, MayBlock)
+PRE(sys_flistxattr, MayBlock)
{
PRINT("sys_flistxattr ( %d, %p, %llu )", arg1, arg2, (ULong)arg3);
@@ -1424,5 +1421,5 @@ PREx(sys_flistxattr, MayBlock)
}
-POSTx(sys_flistxattr)
+POST(sys_flistxattr)
{
if (res > 0 && arg2 != (Addr)NULL)
@@ -1430,5 +1427,5 @@ POSTx(sys_flistxattr)
}
-PREx(sys_removexattr, MayBlock)
+PRE(sys_removexattr, MayBlock)
{
PRINT("sys_removexattr ( %p, %p )", arg1, arg2);
@@ -1438,5 +1435,5 @@ PREx(sys_removexattr, MayBlock)
}
-PREx(sys_lremovexattr, MayBlock)
+PRE(sys_lremovexattr, MayBlock)
{
PRINT("sys_lremovexattr ( %p, %p )", arg1, arg2);
@@ -1446,5 +1443,5 @@ PREx(sys_lremovexattr, MayBlock)
}
-PREx(sys_fremovexattr, MayBlock)
+PRE(sys_fremovexattr, MayBlock)
{
PRINT("sys_fremovexattr ( %d, %p )", arg1, arg2);
@@ -1453,5 +1450,5 @@ PREx(sys_fremovexattr, MayBlock)
}
-PREx(sys_quotactl, 0)
+PRE(sys_quotactl, 0)
{
PRINT("sys_quotactl (0x%x, %p, 0x%x, 0x%x )", arg1,arg2,arg3, arg4);
@@ -1463,5 +1460,5 @@ PREx(sys_quotactl, 0)
// XXX: this wrapper is only suitable for 32-bit platforms
-PREx(sys_lookup_dcookie, 0)
+PRE(sys_lookup_dcookie, 0)
{
PRINT("sys_lookup_dcookie (0x%llx, %p, %d)", LOHI64(arg1,arg2), arg3, arg4);
@@ -1472,5 +1469,5 @@ PREx(sys_lookup_dcookie, 0)
}
-POSTx(sys_lookup_dcookie)
+POST(sys_lookup_dcookie)
{
if (arg3 != (Addr)NULL)
@@ -1478,5 +1475,5 @@ POSTx(sys_lookup_dcookie)
}
-PREx(sys_fsync, MayBlock)
+PRE(sys_fsync, MayBlock)
{
PRINT("sys_fsync ( %d )", arg1);
@@ -1484,5 +1481,5 @@ PREx(sys_fsync, MayBlock)
}
-PREx(sys_fdatasync, MayBlock)
+PRE(sys_fdatasync, MayBlock)
{
PRINT("sys_fdatasync ( %d )", arg1);
@@ -1490,5 +1487,5 @@ PREx(sys_fdatasync, MayBlock)
}
-PREx(sys_msync, MayBlock)
+PRE(sys_msync, MayBlock)
{
PRINT("sys_msync ( %p, %llu, %d )", arg1,(ULong)arg2,arg3);
@@ -1508,5 +1505,5 @@ struct vki_pmsg_strbuf {
};
-PREx(sys_getpmsg, MayBlock)
+PRE(sys_getpmsg, MayBlock)
{
/* LiS getpmsg from http://www.gcom.com/home/linux/lis/ */
@@ -1529,5 +1526,5 @@ PREx(sys_getpmsg, MayBlock)
}
-POSTx(sys_getpmsg)
+POST(sys_getpmsg)
{
struct vki_pmsg_strbuf *ctrl;
@@ -1544,5 +1541,5 @@ POSTx(sys_getpmsg)
}
-PREx(sys_putpmsg, MayBlock)
+PRE(sys_putpmsg, MayBlock)
{
/* LiS putpmsg from http://www.gcom.com/home/linux/lis/ */
@@ -1561,5 +1558,5 @@ PREx(sys_putpmsg, MayBlock)
}
-PREx(sys_getitimer, NBRunInLWP)
+PRE(sys_getitimer, NBRunInLWP)
{
PRINT("sys_getitimer ( %d, %p )", arg1, arg2);
@@ -1568,5 +1565,5 @@ PREx(sys_getitimer, NBRunInLWP)
}
-POSTx(sys_getitimer)
+POST(sys_getitimer)
{
if (arg2 != (Addr)NULL) {
@@ -1575,5 +1572,5 @@ POSTx(sys_getitimer)
}
-PREx(sys_setitimer, NBRunInLWP)
+PRE(sys_setitimer, NBRunInLWP)
{
PRINT("sys_setitimer ( %d, %p, %p )", arg1,arg2,arg3);
@@ -1587,5 +1584,5 @@ PREx(sys_setitimer, NBRunInLWP)
}
-POSTx(sys_setitimer)
+POST(sys_setitimer)
{
if (arg3 != (Addr)NULL) {
@@ -1594,5 +1591,5 @@ POSTx(sys_setitimer)
}
-PREx(sys_syslog, MayBlock)
+PRE(sys_syslog, MayBlock)
{
PRINT("sys_syslog (%d, %p, %d)", arg1,arg2,arg3);
@@ -1607,5 +1604,5 @@ PREx(sys_syslog, MayBlock)
}
-POSTx(sys_syslog)
+POST(sys_syslog)
{
switch (arg1) {
@@ -1618,5 +1615,5 @@ POSTx(sys_syslog)
}
-PREx(sys_personality, 0)
+PRE(sys_personality, 0)
{
PRINT("sys_personality ( %llu )", (ULong)arg1);
@@ -1624,5 +1621,5 @@ PREx(sys_personality, 0)
}
-PREx(sys_chroot, 0)
+PRE(sys_chroot, 0)
{
PRINT("sys_chroot ( %p )", arg1);
@@ -1631,5 +1628,5 @@ PREx(sys_chroot, 0)
}
-PREx(sys_madvise, MayBlock)
+PRE(sys_madvise, MayBlock)
{
PRINT("sys_madvise ( %p, %llu, %d )", arg1,(ULong)arg2,arg3);
@@ -1638,5 +1635,5 @@ PREx(sys_madvise, MayBlock)
}
-PREx(sys_mremap, Special)
+PRE(sys_mremap, Special)
{
// Nb: this is different to the glibc version described in the man pages,
@@ -1651,5 +1648,5 @@ PREx(sys_mremap, Special)
}
-PREx(sys_nice, 0)
+PRE(sys_nice, 0)
{
PRINT("sys_nice ( %d )", arg1);
@@ -1657,5 +1654,5 @@ PREx(sys_nice, 0)
}
-PREx(sys_setfsuid, 0)
+PRE(sys_setfsuid, 0)
{
PRINT("sys_setfsuid ( %d )", arg1);
@@ -1663,5 +1660,5 @@ PREx(sys_setfsuid, 0)
}
-PREx(sys_sysctl, 0)
+PRE(sys_sysctl, 0)
{
PRINT("sys_sysctl ( %p )", arg1 );
@@ -1670,10 +1667,10 @@ PREx(sys_sysctl, 0)
}
-POSTx(sys_sysctl)
+POST(sys_sysctl)
{
POST_MEM_WRITE( arg1, sizeof(struct __vki_sysctl_args) );
}
-PREx(sys_sched_getscheduler, 0/*???*/)
+PRE(sys_sched_getscheduler, 0)
{
PRINT("sys_sched_getscheduler ( %d )", arg1);
@@ -1681,5 +1678,5 @@ PREx(sys_sched_getscheduler, 0/*???*/)
}
-PREx(sys_sched_setscheduler, 0/*???*/)
+PRE(sys_sched_setscheduler, 0)
{
PRINT("sys_sched_setscheduler ( %d, %d, %p )", arg1,arg2,arg3);
@@ -1691,5 +1688,5 @@ PREx(sys_sched_setscheduler, 0/*???*/)
}
-PREx(sys_mlock, MayBlock)
+PRE(sys_mlock, MayBlock)
{
PRINT("sys_mlock ( %p, %llu )", arg1, (ULong)arg2);
@@ -1697,5 +1694,5 @@ PREx(sys_mlock, MayBlock)
}
-PREx(sys_munlock, MayBlock)
+PRE(sys_munlock, MayBlock)
{
PRINT("sys_munlock ( %p, %llu )", arg1, (ULong)arg2);
@@ -1703,5 +1700,5 @@ PREx(sys_munlock, MayBlock)
}
-PREx(sys_mlockall, MayBlock)
+PRE(sys_mlockall, MayBlock)
{
PRINT("sys_mlockall ( %x )", arg1);
@@ -1709,5 +1706,5 @@ PREx(sys_mlockall, MayBlock)
}
-PREx(sys_munlockall, MayBlock)
+PRE(sys_munlockall, MayBlock)
{
PRINT("sys_munlockall ( )");
@@ -1715,5 +1712,5 @@ PREx(sys_munlockall, MayBlock)
}
-PREx(sys_sched_get_priority_max, 0/*???*/)
+PRE(sys_sched_get_priority_max, 0)
{
PRINT("sched_get_priority_max ( %d )", arg1);
@@ -1721,5 +1718,5 @@ PREx(sys_sched_get_priority_max, 0/*???*
}
-PREx(sys_sched_get_priority_min, 0/*???*/)
+PRE(sys_sched_get_priority_min, 0)
{
PRINT("sched_get_priority_min ( %d )", arg1);
@@ -1727,5 +1724,5 @@ PREx(sys_sched_get_priority_min, 0/*???*
}
-PREx(sys_setpriority, 0)
+PRE(sys_setpriority, 0)
{
PRINT("sys_setpriority ( %d, %d, %d )", arg1, arg2, arg3);
@@ -1733,5 +1730,5 @@ PREx(sys_setpriority, 0)
}
-PREx(sys_getpriority, 0)
+PRE(sys_getpriority, 0)
{
PRINT("sys_getpriority ( %d, %d )", arg1, arg2);
@@ -1739,5 +1736,5 @@ PREx(sys_getpriority, 0)
}
-PREx(sys_setfsgid16, 0)
+PRE(sys_setfsgid16, 0)
{
PRINT("sys_setfsgid16 ( %d )", arg1);
@@ -1745,5 +1742,5 @@ PREx(sys_setfsgid16, 0)
}
-PREx(sys_setregid16, 0)
+PRE(sys_setregid16, 0)
{
PRINT("sys_setregid16 ( %d, %d )", arg1, arg2);
@@ -1751,5 +1748,5 @@ PREx(sys_setregid16, 0)
}
-PREx(sys_setresuid16, 0)
+PRE(sys_setresuid16, 0)
{
PRINT("sys_setresuid16 ( %d, %d, %d )", arg1, arg2, arg3);
@@ -1758,5 +1755,5 @@ PREx(sys_setresuid16, 0)
}
-PREx(sys_setresuid, 0)
+PRE(sys_setresuid, 0)
{
PRINT("sys_setresuid ( %d, %d, %d )", arg1, arg2, arg3);
@@ -1765,5 +1762,5 @@ PREx(sys_setresuid, 0)
}
-PREx(sys_setfsuid16, 0)
+PRE(sys_setfsuid16, 0)
{
PRINT("sys_setfsuid16 ( %d )", arg1);
@@ -1771,5 +1768,5 @@ PREx(sys_setfsuid16, 0)
}
-PREx(sys_sendfile, MayBlock)
+PRE(sys_sendfile, MayBlock)
{
PRINT("sys_sendfile ( %d, %d, %p, %llu )", arg1,arg2,arg3,(ULong)arg4);
@@ -1781,10 +1778,10 @@ PREx(sys_sendfile, MayBlock)
}
-POSTx(sys_sendfile)
+POST(sys_sendfile)
{
POST_MEM_WRITE( arg3, sizeof( vki_off_t ) );
}
-PREx(sys_sendfile64, MayBlock)
+PRE(sys_sendfile64, MayBlock)
{
PRINT("sendfile64 ( %d, %d, %p, %llu )",arg1,arg2,arg3,(ULong)arg4);
@@ -1796,5 +1793,5 @@ PREx(sys_sendfile64, MayBlock)
}
-POSTx(sys_sendfile64)
+POST(sys_sendfile64)
{
if (arg3 != (UWord)NULL ) {
@@ -1804,5 +1801,5 @@ POSTx(sys_sendfile64)
// XXX: only for 32-bit archs
-PREx(sys_pwrite64, MayBlock)
+PRE(sys_pwrite64, MayBlock)
{
PRINT("sys_pwrite64 ( %d, %p, %llu, %lld )",
@@ -1814,5 +1811,5 @@ PREx(sys_pwrite64, MayBlock)
}
-PREx(sys_sync, MayBlock)
+PRE(sys_sync, MayBlock)
{
PRINT("sys_sync ( )");
@@ -1820,5 +1817,5 @@ PREx(sys_sync, MayBlock)
}
-PREx(sys_fstatfs, 0)
+PRE(sys_fstatfs, 0)
{
PRINT("sys_fstatfs ( %d, %p )",arg1,arg2);
@@ -1828,10 +1825,10 @@ PREx(sys_fstatfs, 0)
}
-POSTx(sys_fstatfs)
+POST(sys_fstatfs)
{
POST_MEM_WRITE( arg2, sizeof(struct vki_statfs) );
}
-PREx(sys_fstatfs64, 0)
+PRE(sys_fstatfs64, 0)
{
PRINT("sys_fstatfs64 ( %d, %llu, %p )",arg1,(ULong)arg2,arg3);
@@ -1841,10 +1838,10 @@ PREx(sys_fstatfs64, 0)
}
-POSTx(sys_fstatfs64)
+POST(sys_fstatfs64)
{
POST_MEM_WRITE( arg3, arg2 );
}
-PREx(sys_getsid, 0)
+PRE(sys_getsid, 0)
{
PRINT("sys_getsid ( %d )", arg1);
@@ -1853,5 +1850,5 @@ PREx(sys_getsid, 0)
// XXX: only for 32-bit archs
-PREx(sys_pread64, MayBlock)
+PRE(sys_pread64, MayBlock)
{
PRINT("sys_pread64 ( %d, %p, %llu, %lld )",
@@ -1863,5 +1860,5 @@ PREx(sys_pread64, MayBlock)
}
-POSTx(sys_pread64)
+POST(sys_pread64)
{
if (res > 0) {
@@ -1870,5 +1867,5 @@ POSTx(sys_pread64)
}
-PREx(sys_mknod, 0)
+PRE(sys_mknod, 0)
{
PRINT("sys_mknod ( %p, 0x%x, 0x%x )", arg1, arg2, arg3 );
@@ -1878,5 +1875,5 @@ PREx(sys_mknod, 0)
}
-PREx(sys_flock, MayBlock)
+PRE(sys_flock, MayBlock)
{
PRINT("sys_flock ( %d, %d )", arg1, arg2 );
@@ -1884,5 +1881,5 @@ PREx(sys_flock, MayBlock)
}
-PREx(sys_init_module, MayBlock)
+PRE(sys_init_module, MayBlock)
{
PRINT("sys_init_module ( %p, %llu, %p )", arg1, (ULong)arg2, arg3 );
@@ -1893,5 +1890,5 @@ PREx(sys_init_module, MayBlock)
}
-PREx(sys_ioperm, 0)
+PRE(sys_ioperm, 0)
{
PRINT("sys_ioperm ( %d, %d, %d )", arg1, arg2, arg3 );
@@ -1900,5 +1897,5 @@ PREx(sys_ioperm, 0)
}
-PREx(sys_capget, 0)
+PRE(sys_capget, 0)
{
PRINT("sys_capget ( %p, %p )", arg1, arg2 );
@@ -1911,5 +1908,5 @@ PREx(sys_capget, 0)
}
-POSTx(sys_capget)
+POST(sys_capget)
{
if (arg2 != (Addr)NULL)
@@ -1917,5 +1914,5 @@ POSTx(sys_capget)
}
-PREx(sys_capset, 0)
+PRE(sys_capset, 0)
{
PRINT("sys_capset ( %p, %p )", arg1, arg2 );
@@ -1943,5 +1940,5 @@ void pre_argv_envp(Addr a, ThreadId tid,
// XXX: prototype here seemingly doesn't match the prototype for i386-linux,
// but it seems to work nonetheless...
-PREx(sys_execve, Special)
+PRE(sys_execve, Special)
{
PRINT("sys_execve ( %p(%s), %p, %p )", arg1, arg1, arg2, arg3);
@@ -2051,5 +2048,5 @@ PREx(sys_execve, Special)
}
-PREx(sys_access, 0)
+PRE(sys_access, 0)
{
PRINT("sys_access ( %p(%s), %d )", arg1,arg1,arg2);
@@ -2058,5 +2055,5 @@ PREx(sys_access, 0)
}
-PREx(sys_alarm, NBRunInLWP)
+PRE(sys_alarm, NBRunInLWP)
{
PRINT("sys_alarm ( %d )", arg1);
@@ -2064,5 +2061,5 @@ PREx(sys_alarm, NBRunInLWP)
}
-PREx(sys_brk, Special)
+PRE(sys_brk, Special)
{
Addr brk_limit = VG_(brk_limit);
@@ -2106,5 +2103,5 @@ PREx(sys_brk, Special)
}
-PREx(sys_chdir, 0)
+PRE(sys_chdir, 0)
{
PRINT("sys_chdir ( %p )", arg1);
@@ -2113,5 +2110,5 @@ PREx(sys_chdir, 0)
}
-PREx(sys_chmod, 0)
+PRE(sys_chmod, 0)
{
PRINT("sys_chmod ( %p, %d )", arg1,arg2);
@@ -2120,5 +2117,5 @@ PREx(sys_chmod, 0)
}
-PREx(sys_chown16, 0)
+PRE(sys_chown16, 0)
{
PRINT("sys_chown16 ( %p, 0x%x, 0x%x )", arg1,arg2,arg3);
@@ -2129,5 +2126,5 @@ PREx(sys_chown16, 0)
}
-PREx(sys_chown, 0)
+PRE(sys_chown, 0)
{
/* int chown(const char *path, uid_t owner, gid_t group); */
@@ -2138,5 +2135,5 @@ PREx(sys_chown, 0)
}
-PREx(sys_lchown, 0)
+PRE(sys_lchown, 0)
{
PRINT("sys_lchown ( %p, 0x%x, 0x%x )", arg1,arg2,arg3);
@@ -2146,5 +2143,5 @@ PREx(sys_lchown, 0)
}
-PREx(sys_close, 0)
+PRE(sys_close, 0)
{
PRINT("sys_close ( %d )", arg1);
@@ -2156,10 +2153,10 @@ PREx(sys_close, 0)
}
-POSTx(sys_close)
+POST(sys_close)
{
if (VG_(clo_track_fds)) record_fd_close(tid, arg1);
}
-PREx(sys_dup, 0)
+PRE(sys_dup, 0)
{
PRINT("sys_dup ( %d )", arg1);
@@ -2167,5 +2164,5 @@ PREx(sys_dup, 0)
}
-POSTx(sys_dup)
+POST(sys_dup)
{
if (!fd_allowed(res, "dup", tid, True)) {
@@ -2178,5 +2175,5 @@ POSTx(sys_dup)
}
-PREx(sys_dup2, 0)
+PRE(sys_dup2, 0)
{
PRINT("sys_dup2 ( %d, %d )", arg1,arg2);
@@ -2186,5 +2183,5 @@ PREx(sys_dup2, 0)
}
-POSTx(sys_dup2)
+POST(sys_dup2)
{
if (VG_(clo_track_fds))
@@ -2192,5 +2189,5 @@ POSTx(sys_dup2)
}
-PREx(sys_fcntl, 0)
+PRE(sys_fcntl, 0)
{
PRINT("sys_fcntl ( %d, %d, %d )", arg1,arg2,arg3);
@@ -2201,5 +2198,5 @@ PREx(sys_fcntl, 0)
}
-POSTx(sys_fcntl)
+POST(sys_fcntl)
{
if (arg2 == VKI_F_DUPFD) {
@@ -2214,5 +2211,5 @@ POSTx(sys_fcntl)
}
-PREx(sys_fchdir, 0)
+PRE(sys_fchdir, 0)
{
PRINT("sys_fchdir ( %d )", arg1);
@@ -2220,5 +2217,5 @@ PREx(sys_fchdir, 0)
}
-PREx(sys_fchown16, 0)
+PRE(sys_fchown16, 0)
{
PRINT("sys_fchown16 ( %d, %d, %d )", arg1,arg2,arg3);
@@ -2227,5 +2224,5 @@ PREx(sys_fchown16, 0)
}
-PREx(sys_fchown, 0)
+PRE(sys_fchown, 0)
{
PRINT("sys_fchown ( %d, %d, %d )", arg1,arg2,arg3);
@@ -2234,5 +2231,5 @@ PREx(sys_fchown, 0)
}
-PREx(sys_fchmod, 0)
+PRE(sys_fchmod, 0)
{
PRINT("sys_fchmod ( %d, %d )", arg1,arg2);
@@ -2241,5 +2238,5 @@ PREx(sys_fchmod, 0)
// XXX: wrapper only suitable for 32-bit systems
-PREx(sys_fcntl64, 0)
+PRE(sys_fcntl64, 0)
{
PRINT("sys_fcntl64 ( %d, %d, %d )", arg1,arg2,arg3);
@@ -2250,5 +2247,5 @@ PREx(sys_fcntl64, 0)
}
-POSTx(sys_fcntl64)
+POST(sys_fcntl64)
{
if (arg2 == VKI_F_DUPFD) {
@@ -2263,5 +2260,5 @@ POSTx(sys_fcntl64)
}
-PREx(sys_newfstat, 0)
+PRE(sys_newfstat, 0)
{
PRINT("sys_newfstat ( %d, %p )", arg1,arg2);
@@ -2270,5 +2267,5 @@ PREx(sys_newfstat, 0)
}
-POSTx(sys_newfstat)
+POST(sys_newfstat)
{
POST_MEM_WRITE( arg2, sizeof(struct vki_stat) );
@@ -2279,5 +2276,5 @@ static vki_sigset_t fork_saved_mask;
// In Linux, the sys_fork() function varies across architectures, but we
// ignore the various args it gets, and so it looks arch-neutral. Hmm.
-PREx(sys_fork, 0)
+PRE(sys_fork, 0)
{
vki_sigset_t mask;
@@ -2296,5 +2293,5 @@ PREx(sys_fork, 0)
}
-POSTx(sys_fork)
+POST(sys_fork)
{
if (res == 0) {
@@ -2321,5 +2318,5 @@ POSTx(sys_fork)
// XXX: x86-specific
-PREx(sys_clone, Special)
+PRE(sys_clone, Special)
{
PRINT("sys_clone ( %d, %p, %p, %p, %p )",arg1,arg2,arg3,arg4,arg5);
@@ -2346,5 +2343,5 @@ PREx(sys_clone, Special)
}
-PREx(sys_ftruncate, MayBlock)
+PRE(sys_ftruncate, MayBlock)
{
PRINT("sys_ftruncate ( %d, %lld )", arg1,(ULong)arg2);
@@ -2352,5 +2349,5 @@ PREx(sys_ftruncate, MayBlock)
}
-PREx(sys_truncate, MayBlock)
+PRE(sys_truncate, MayBlock)
{
PRINT("sys_truncate ( %p(%s), %d )", arg1,arg1,arg2);
@@ -2361,5 +2358,5 @@ PREx(sys_truncate, MayBlock)
// XXX: this wrapper is only suitable for 32-bit platforms
-PREx(sys_ftruncate64, MayBlock)
+PRE(sys_ftruncate64, MayBlock)
{
PRINT("sys_ftruncate64 ( %d, %lld )", arg1, LOHI64(arg2,arg3));
@@ -2370,5 +2367,5 @@ PREx(sys_ftruncate64, MayBlock)
// XXX: this wrapper is only suitable for 32-bit platforms
-PREx(sys_truncate64, MayBlock)
+PRE(sys_truncate64, MayBlock)
{
PRINT("sys_truncate64 ( %p, %lld )", arg1, LOHI64(arg2, arg3));
@@ -2380,5 +2377,5 @@ PREx(sys_truncate64, MayBlock)
-PREx(sys_getdents, MayBlock)
+PRE(sys_getdents, MayBlock)
{
PRINT("sys_getdents ( %d, %p, %d )", arg1,arg2,arg3);
@@ -2389,5 +2386,5 @@ PREx(sys_getdents, MayBlock)
}
-POSTx(sys_getdents)
+POST(sys_getdents)
{
if (res > 0)
@@ -2395,5 +2392,5 @@ POSTx(sys_getdents)
}
-PREx(sys_getdents64, MayBlock)
+PRE(sys_getdents64, MayBlock)
{
PRINT("sys_getdents64 ( %d, %p, %d )",arg1,arg2,arg3);
@@ -2404,5 +2401,5 @@ PREx(sys_getdents64, MayBlock)
}
-POSTx(sys_getdents64)
+POST(sys_getdents64)
{
if (res > 0)
@@ -2410,5 +2407,5 @@ POSTx(sys_getdents64)
}
-PREx(sys_getgroups16, 0)
+PRE(sys_getgroups16, 0)
{
PRINT("sys_getgroups16 ( %d, %p )", arg1, arg2);
@@ -2418,5 +2415,5 @@ PREx(sys_getgroups16, 0)
}
-POSTx(sys_getgroups16)
+POST(sys_getgroups16)
{
if (arg1 > 0 && res > 0)
@@ -2424,5 +2421,5 @@ POSTx(sys_getgroups16)
}
-PREx(sys_getgroups, 0)
+PRE(sys_getgroups, 0)
{
PRINT("sys_getgroups ( %d, %p )", arg1, arg2);
@@ -2432,5 +2429,5 @@ PREx(sys_getgroups, 0)
}
-POSTx(sys_getgroups)
+POST(sys_getgroups)
{
if (arg1 > 0 && res > 0)
@@ -2438,5 +2435,5 @@ POSTx(sys_getgroups)
}
-PREx(sys_getcwd, 0)
+PRE(sys_getcwd, 0)
{
// Note that the kernel version of getcwd() behaves quite differently to
@@ -2447,5 +2444,5 @@ PREx(sys_getcwd, 0)
}
-POSTx(sys_getcwd)
+POST(sys_getcwd)
{
if (res != (Addr)NULL)
@@ -2453,5 +2450,5 @@ POSTx(sys_getcwd)
}
-PREx(sys_geteuid16, 0)
+PRE(sys_geteuid16, 0)
{
PRINT("sys_geteuid16 ( )");
@@ -2459,5 +2456,5 @@ PREx(sys_geteuid16, 0)
}
-PREx(sys_geteuid, 0)
+PRE(sys_geteuid, 0)
{
PRINT("sys_geteuid ( )");
@@ -2465,5 +2462,5 @@ PREx(sys_geteuid, 0)
}
-PREx(sys_getegid16, 0)
+PRE(sys_getegid16, 0)
{
PRINT("sys_getegid16 ( )");
@@ -2471,5 +2468,5 @@ PREx(sys_getegid16, 0)
}
-PREx(sys_getegid, 0)
+PRE(sys_getegid, 0)
{
PRINT("sys_getegid ( )");
@@ -2477,5 +2474,5 @@ PREx(sys_getegid, 0)
}
-PREx(sys_getgid16, 0)
+PRE(sys_getgid16, 0)
{
PRINT("sys_getgid16 ( )");
@@ -2483,5 +2480,5 @@ PREx(sys_getgid16, 0)
}
-PREx(sys_getgid, 0)
+PRE(sys_getgid, 0)
{
PRINT("sys_getgid ( )");
@@ -2489,5 +2486,5 @@ PREx(sys_getgid, 0)
}
-PREx(sys_getpid, 0)
+PRE(sys_getpid, 0)
{
PRINT("sys_getpid ()");
@@ -2495,5 +2492,5 @@ PREx(sys_getpid, 0)
}
-PREx(sys_getpgid, 0)
+PRE(sys_getpgid, 0)
{
PRINT("sys_getpgid ( %d )", arg1);
@@ -2501,5 +2498,5 @@ PREx(sys_getpgid, 0)
}
-PREx(sys_getpgrp, 0)
+PRE(sys_getpgrp, 0)
{
PRINT("sys_getpgrp ()");
@@ -2507,5 +2504,5 @@ PREx(sys_getpgrp, 0)
}
-PREx(sys_getppid, 0)
+PRE(sys_getppid, 0)
{
PRINT("sys_getppid ()");
@@ -2513,5 +2510,5 @@ PREx(sys_getppid, 0)
}
-PREx(sys_getresgid16, 0)
+PRE(sys_getresgid16, 0)
{
PRINT("sys_getresgid16 ( %p, %p, %p )", arg1,arg2,arg3);
@@ -2524,5 +2521,5 @@ PREx(sys_getresgid16, 0)
}
-POSTx(sys_getresgid16)
+POST(sys_getresgid16)
{
if (res == 0) {
@@ -2533,5 +2530,5 @@ POSTx(sys_getresgid16)
}
-PREx(sys_getresgid, 0)
+PRE(sys_getresgid, 0)
{
PRINT("sys_getresgid ( %p, %p, %p )", arg1,arg2,arg3);
@@ -2543,5 +2540,5 @@ PREx(sys_getresgid, 0)
}
-POSTx(sys_getresgid)
+POST(sys_getresgid)
{
if (res == 0) {
@@ -2552,5 +2549,5 @@ POSTx(sys_getresgid)
}
-PREx(sys_getresuid16, 0)
+PRE(sys_getresuid16, 0)
{
PRINT("sys_getresuid16 ( %p, %p, %p )", arg1,arg2,arg3);
@@ -2563,5 +2560,5 @@ PREx(sys_getresuid16, 0)
}
-POSTx(sys_getresuid16)
+POST(sys_getresuid16)
{
if (res == 0) {
@@ -2572,5 +2569,5 @@ POSTx(sys_getresuid16)
}
-PREx(sys_getresuid, 0)
+PRE(sys_getresuid, 0)
{
PRINT("sys_getresuid ( %p, %p, %p )", arg1,arg2,arg3);
@@ -2582,5 +2579,5 @@ PREx(sys_getresuid, 0)
}
-POSTx(sys_getresuid)
+POST(sys_getresuid)
{
if (res == 0) {
@@ -2611,5 +2608,5 @@ static void common_post_getrlimit(UWord
}
-PREx(sys_old_getrlimit, 0)
+PRE(sys_old_getrlimit, 0)
{
PRINT("sys_old_getrlimit ( %d, %p )", arg1,arg2);
@@ -2619,10 +2616,10 @@ PREx(sys_old_getrlimit, 0)
}
-POSTx(sys_old_getrlimit)
+POST(sys_old_getrlimit)
{
common_post_getrlimit(arg1, arg2);
}
-PREx(sys_getrlimit, 0)
+PRE(sys_getrlimit, 0)
{
PRINT("sys_getrlimit ( %d, %p )", arg1,arg2);
@@ -2632,10 +2629,10 @@ PREx(sys_getrlimit, 0)
}
-POSTx(sys_getrlimit)
+POST(sys_getrlimit)
{
common_post_getrlimit(arg1, arg2);
}
-PREx(sys_getrusage, 0)
+PRE(sys_getrusage, 0)
{
/* int getrusage (int who, struct rusage *usage); */
@@ -2645,5 +2642,5 @@ PREx(sys_getrusage, 0)
}
-POSTx(sys_getrusage)
+POST(sys_getrusage)
{
if (res == 0)
@@ -2651,5 +2648,5 @@ POSTx(sys_getrusage)
}
-PREx(sys_gettimeofday, 0)
+PRE(sys_gettimeofday, 0)
{
PRINT("sys_gettimeofday ( %p, %p )", arg1,arg2);
@@ -2661,5 +2658,5 @@ PREx(sys_gettimeofday, 0)
}
-POSTx(sys_gettimeofday)
+POST(sys_gettimeofday)
{
if (res == 0) {
@@ -2670,5 +2667,5 @@ POSTx(sys_gettimeofday)
}
-PREx(sys_settimeofday, 0)
+PRE(sys_settimeofday, 0)
{
PRINT("sys_settimeofday ( %p, %p )", arg1,arg2);
@@ -2682,5 +2679,5 @@ PREx(sys_settimeofday, 0)
}
-PREx(sys_getuid16, 0)
+PRE(sys_getuid16, 0)
{
PRINT("sys_getuid16 ( )");
@@ -2688,5 +2685,5 @@ PREx(sys_getuid16, 0)
}
-PREx(sys_getuid, 0)
+PRE(sys_getuid, 0)
{
PRINT("sys_getuid ( )");
@@ -2696,5 +2693,5 @@ PREx(sys_getuid, 0)
// XXX: x86-specific
// XXX: should use the constants here (eg. SHMAT), not the numbers directly!
-PREx(sys_ipc, 0)
+PRE(sys_ipc, 0)
{
PRINT("sys_ipc ( %d, %d, %d, %d, %p, %d )", arg1,arg2,arg3,arg4,arg5,arg6);
@@ -2958,5 +2955,5 @@ PREx(sys_ipc, 0)
}
-POSTx(sys_ipc)
+POST(sys_ipc)
{
switch (arg1 /* call */) {
@@ -3139,5 +3136,5 @@ POSTx(sys_ipc)
// XXX: I reckon some of these cases must be x86-specific
-PREx(sys_ioctl, MayBlock)
+PRE(sys_ioctl, MayBlock)
{
PRINT("sys_ioctl ( %d, 0x%x, %p )",arg1,arg2,arg3);
@@ -3902,5 +3899,5 @@ PREx(sys_ioctl, MayBlock)
}
-POSTx(sys_ioctl)
+POST(sys_ioctl)
{
switch (arg2 /* request */) {
@@ -4412,5 +4409,5 @@ POSTx(sys_ioctl)
}
-PREx(sys_kill, 0)
+PRE(sys_kill, 0)
{
/* int kill(pid_t pid, int sig); */
@@ -4421,5 +4418,5 @@ PREx(sys_kill, 0)
}
-POSTx(sys_kill)
+POST(sys_kill)
{
/* If this was a self-kill then wait for a signal to be
@@ -4439,5 +4436,5 @@ POSTx(sys_kill)
}
-PREx(sys_link, MayBlock)
+PRE(sys_link, MayBlock)
{
PRINT("sys_link ( %p, %p)", arg1, arg2);
@@ -4447,5 +4444,5 @@ PREx(sys_link, MayBlock)
}
-PREx(sys_lseek, 0)
+PRE(sys_lseek, 0)
{
PRINT("sys_lseek ( %d, %d, %d )", arg1,arg2,arg3);
@@ -4454,5 +4451,5 @@ PREx(sys_lseek, 0)
}
-PREx(sys_llseek, 0)
+PRE(sys_llseek, 0)
{
PRINT("sys_llseek ( %d, 0x%x, 0x%x, %p, %d )", arg1,arg2,arg3,arg4,arg5);
@@ -4464,5 +4461,5 @@ PREx(sys_llseek, 0)
}
-POSTx(sys_llseek)
+POST(sys_llseek)
{
if (res == 0)
@@ -4470,5 +4467,5 @@ POSTx(sys_llseek)
}
-PREx(sys_newlstat, 0)
+PRE(sys_newlstat, 0)
{
PRINT("sys_newlstat ( %p(%s), %p )", arg1,arg1,arg2);
@@ -4478,5 +4475,5 @@ PREx(sys_newlstat, 0)
}
-POSTx(sys_newlstat)
+POST(sys_newlstat)
{
if (res == 0) {
@@ -4485,5 +4482,5 @@ POSTx(sys_newlstat)
}
-PREx(sys_lstat64, 0)
+PRE(sys_lstat64, 0)
{
PRINT("sys_lstat64 ( %p(%s), %p )",arg1,arg1,arg2);
@@ -4493,5 +4490,5 @@ PREx(sys_lstat64, 0)
}
-POSTx(sys_lstat64)
+POST(sys_lstat64)
{
if (res == 0) {
@@ -4500,5 +4497,5 @@ POSTx(sys_lstat64)
}
-PREx(sys_mkdir, MayBlock)
+PRE(sys_mkdir, MayBlock)
{
PRINT("sys_mkdir ( %p, %d )", arg1,arg2);
@@ -4507,5 +4504,5 @@ PREx(sys_mkdir, MayBlock)
}
-PREx(sys_mmap2, 0)
+PRE(sys_mmap2, 0)
{
// Exactly like old_mmap() except:
@@ -4532,5 +4529,5 @@ PREx(sys_mmap2, 0)
}
-POSTx(sys_mmap2)
+POST(sys_mmap2)
{
vg_assert(valid_client_addr(res, arg2, tid, "mmap2"));
@@ -4539,5 +4536,5 @@ POSTx(sys_mmap2)
}
-PREx(old_mmap, Special)
+PRE(old_mmap, Special)
{
/* struct mmap_arg_struct {
@@ -4580,5 +4577,5 @@ PREx(old_mmap, Special)
}
-PREx(sys_mprotect, 0)
+PRE(sys_mprotect, 0)
{
PRINT("sys_mprotect ( %p, %llu, %d )", arg1,(ULong)arg2,arg3);
@@ -4590,5 +4587,5 @@ PREx(sys_mprotect, 0)
}
-POSTx(sys_mprotect)
+POST(sys_mprotect)
{
Addr a = arg1;
@@ -4604,5 +4601,5 @@ POSTx(sys_mprotect)
}
-PREx(sys_munmap, 0)
+PRE(sys_munmap, 0)
{
PRINT("sys_munmap ( %p, %llu )", arg1,(ULong)arg2);
@@ -4613,5 +4610,5 @@ PREx(sys_munmap, 0)
}
-POSTx(sys_munmap)
+POST(sys_munmap)
{
Addr a = arg1;
@@ -4623,5 +4620,5 @@ POSTx(sys_munmap)
}
-PREx(sys_mincore, 0)
+PRE(sys_mincore, 0)
{
PRINT("sys_mincore ( %p, %llu, %p )", arg1,(ULong)arg2,arg3);
@@ -4632,10 +4629,10 @@ PREx(sys_mincore, 0)
}
-POSTx(sys_mincore)
+POST(sys_mincore)
{
POST_MEM_WRITE( arg3, (arg2 + 4096 - 1) / 4096 );
}
-PREx(sys_nanosleep, MayBlock|PostOnFail)
+PRE(sys_nanosleep, MayBlock|PostOnFail)
{
PRINT("sys_nanosleep ( %p, %p )", arg1,arg2);
@@ -4647,5 +4644,5 @@ PREx(sys_nanosleep, MayBlock|PostOnFail)
}
-POSTx(sys_nanosleep)
+POST(sys_nanosleep)
{
if (arg2 != (UWord)NULL && res == -VKI_EINTR)
@@ -4653,5 +4650,5 @@ POSTx(sys_nanosleep)
}
-PREx(sys_open, MayBlock)
+PRE(sys_open, MayBlock)
{
if (arg2 & VKI_O_CREAT) {
@@ -4669,5 +4666,5 @@ PREx(sys_open, MayBlock)
}
-POSTx(sys_open)
+POST(sys_open)
{
if (!fd_allowed(res, "open", tid, True)) {
@@ -4680,5 +4677,5 @@ POSTx(sys_open)
}
-PREx(sys_read, MayBlock)
+PRE(sys_read, MayBlock)
{
PRINT("sys_read ( %d, %p, %llu )", arg1, arg2, (ULong)arg3);
@@ -4692,10 +4689,10 @@ PREx(sys_read, MayBlock)
}
-POSTx(sys_read)
+POST(sys_read)
{
POST_MEM_WRITE( arg2, res );
}
-PREx(sys_write, MayBlock)
+PRE(sys_write, MayBlock)
{
PRINT("sys_write ( %d, %p, %llu )", arg1, arg2, (ULong)arg3);
@@ -4708,5 +4705,5 @@ PREx(sys_write, MayBlock)
}
-PREx(sys_creat, MayBlock)
+PRE(sys_creat, MayBlock)
{
PRINT("sys_creat ( %p(%s), %d )", arg1,arg1,arg2);
@@ -4715,5 +4712,5 @@ PREx(sys_creat, MayBlock)
}
-POSTx(sys_creat)
+POST(sys_creat)
{
if (!fd_allowed(res, "creat", tid, True)) {
@@ -4727,5 +4724,5 @@ POSTx(sys_creat)
// XXX: sort of x86-specific
-PREx(sys_pipe, 0)
+PRE(sys_pipe, 0)
{
PRINT("sys_pipe ( %p )", arg1);
@@ -4734,5 +4731,5 @@ PREx(sys_pipe, 0)
}
-POSTx(sys_pipe)
+POST(sys_pipe)
{
// XXX: use of Int here -- 32-bit-specific?
@@ -4754,5 +4751,5 @@ POSTx(sys_pipe)
// XXX: x86-specific, due to pollfd struct
-PREx(sys_poll, MayBlock)
+PRE(sys_poll, MayBlock)
{
/* struct pollfd {
@@ -4779,5 +4776,5 @@ PREx(sys_poll, MayBlock)
}
-POSTx(sys_poll)
+POST(sys_poll)
{
if (res > 0) {
@@ -4790,5 +4787,5 @@ POSTx(sys_poll)
}
-PREx(sys_epoll_create, 0)
+PRE(sys_epoll_create, 0)
{
PRINT("sys_epoll_create ( %d )", arg1);
@@ -4796,5 +4793,5 @@ PREx(sys_epoll_create, 0)
}
-POSTx(sys_epoll_create)
+POST(sys_epoll_create)
{
if (!fd_allowed(res, "epoll_create", tid, True)) {
@@ -4807,5 +4804,5 @@ POSTx(sys_epoll_create)
}
-PREx(sys_epoll_ctl, 0)
+PRE(sys_epoll_ctl, 0)
{
static const char* epoll_ctl_s[3] = {
@@ -4821,5 +4818,5 @@ PREx(sys_epoll_ctl, 0)
}
-PREx(sys_epoll_wait, MayBlock)
+PRE(sys_epoll_wait, MayBlock)
{
PRINT("sys_epoll_wait ( %d, %p, %d, %d )", arg1, arg2, arg3, arg4);
@@ -4830,5 +4827,5 @@ PREx(sys_epoll_wait, MayBlock)
}
-POSTx(sys_epoll_wait)
+POST(sys_epoll_wait)
{
if (res > 0)
@@ -4836,5 +4833,5 @@ POSTx(sys_epoll_wait)
}
-PREx(sys_readlink, 0)
+PRE(sys_readlink, 0)
{
PRINT("sys_readlink ( %p, %p, %llu )", arg1,arg2,(ULong)arg3);
@@ -4845,10 +4842,10 @@ PREx(sys_readlink, 0)
}
-POSTx(sys_readlink)
+POST(sys_readlink)
{
POST_MEM_WRITE( arg2, res );
}
-PREx(sys_readv, MayBlock)
+PRE(sys_readv, MayBlock)
{
Int i;
@@ -4873,5 +4870,5 @@ PREx(sys_readv, MayBlock)
}
-POSTx(sys_readv)
+POST(sys_readv)
{
if (res > 0) {
@@ -4891,5 +4888,5 @@ POSTx(sys_readv)
}
-PREx(sys_rename, 0)
+PRE(sys_rename, 0)
{
PRINT("sys_rename ( %p, %p )", arg1, arg2 );
@@ -4899,5 +4896,5 @@ PREx(sys_rename, 0)
}
-PREx(sys_rmdir, MayBlock)
+PRE(sys_rmdir, MayBlock)
{
PRINT("sys_rmdir ( %p )", arg1);
@@ -4906,5 +4903,5 @@ PREx(sys_rmdir, MayBlock)
}
-PREx(sys_sched_setparam, 0/*???*/)
+PRE(sys_sched_setparam, 0)
{
PRINT("sched_setparam ( %d, %p )", arg1, arg2 );
@@ -4914,10 +4911,10 @@ PREx(sys_sched_setparam, 0/*???*/)
}
-POSTx(sys_sched_setparam)
+POST(sys_sched_setparam)
{
POST_MEM_WRITE( arg2, sizeof(struct vki_sched_param) );
}
-PREx(sys_sched_getparam, 0/*???*/)
+PRE(sys_sched_getparam, 0)
{
PRINT("sched_getparam ( %d, %p )", arg1, arg2 );
@@ -4927,10 +4924,10 @@ PREx(sys_sched_getparam, 0/*???*/)
}
-POSTx(sys_sched_getparam)
+POST(sys_sched_getparam)
{
POST_MEM_WRITE( arg2, sizeof(struct vki_sched_param) );
}
-PREx(old_select, MayBlock)
+PRE(old_select, MayBlock)
{
/* struct sel_arg_struct {
@@ -4965,5 +4962,5 @@ PREx(old_select, MayBlock)
}
-PREx(sys_select, MayBlock)
+PRE(sys_select, MayBlock)
{
PRINT("sys_select ( %d, %p, %p, %p, %p )", arg1,arg2,arg3,arg4,arg5);
@@ -4985,5 +4982,5 @@ PREx(sys_select, MayBlock)
}
-PREx(sys_setfsgid, 0)
+PRE(sys_setfsgid, 0)
{
PRINT("sys_setfsgid ( %d )", arg1);
@@ -4991,5 +4988,5 @@ PREx(sys_setfsgid, 0)
}
-PREx(sys_setgid16, 0)
+PRE(sys_setgid16, 0)
{
PRINT("sys_setgid16 ( %d )", arg1);
@@ -4997,5 +4994,5 @@ PREx(sys_setgid16, 0)
}
-PREx(sys_setgid, 0)
+PRE(sys_setgid, 0)
{
PRINT("sys_setgid ( %d )", arg1);
@@ -5003,5 +5000,5 @@ PREx(sys_setgid, 0)
}
-PREx(sys_setsid, 0)
+PRE(sys_setsid, 0)
{
PRINT("sys_setsid ( )");
@@ -5009,5 +5006,5 @@ PREx(sys_setsid, 0)
}
-PREx(sys_setgroups16, 0)
+PRE(sys_setgroups16, 0)
{
PRINT("sys_setgroups16 ( %llu, %p )", (ULong)arg1, arg2);
@@ -5017,5 +5014,5 @@ PREx(sys_setgroups16, 0)
}
-PREx(sys_setgroups, 0)
+PRE(sys_setgroups, 0)
{
PRINT("setgroups ( %llu, %p )", (ULong)arg1, arg2);
@@ -5025,5 +5022,5 @@ PREx(sys_setgroups, 0)
}
-PREx(sys_setpgid, 0)
+PRE(sys_setpgid, 0)
{
PRINT("setpgid ( %d, %d )", arg1, arg2);
@@ -5031,10 +5028,10 @@ PREx(sys_setpgid, 0)
}
-POSTx(sys_setpgid)
+POST(sys_setpgid)
{
VG_(main_pgrp) = VG_(getpgrp)();
}
-PREx(sys_setregid, 0)
+PRE(sys_setregid, 0)
{
PRINT("sys_setregid ( %d, %d )", arg1, arg2);
@@ -5042,5 +5039,5 @@ PREx(sys_setregid, 0)
}
-PREx(sys_setreuid16, 0)
+PRE(sys_setreuid16, 0)
{
PRINT("setreuid16 ( 0x%x, 0x%x )", arg1, arg2);
@@ -5048,5 +5045,5 @@ PREx(sys_setreuid16, 0)
}
-PREx(sys_setreuid, 0)
+PRE(sys_setreuid, 0)
{
PRINT("sys_setreuid ( 0x%x, 0x%x )", arg1, arg2);
@@ -5054,5 +5051,5 @@ PREx(sys_setreuid, 0)
}
-PREx(sys_setrlimit, 0)
+PRE(sys_setrlimit, 0)
{
PRINT("sys_setrlimit ( %d, %p )", arg1,arg2);
@@ -5094,5 +5091,5 @@ PREx(sys_setrlimit, 0)
}
-PREx(sys_setuid16, 0)
+PRE(sys_setuid16, 0)
{
PRINT("sys_setuid16 ( %d )", arg1);
@@ -5100,5 +5097,5 @@ PREx(sys_setuid16, 0)
}
-PREx(sys_setuid, 0)
+PRE(sys_setuid, 0)
{
PRINT("sys_setuid ( %d )", arg1);
@@ -5106,5 +5103,5 @@ PREx(sys_setuid, 0)
}
-PREx(sys_socketcall, MayBlock)
+PRE(sys_socketcall, MayBlock)
{
PRINT("sys_socketcall ( %d, %p )",arg1,arg2);
@@ -5307,5 +5304,5 @@ PREx(sys_socketcall, MayBlock)
}
-POSTx(sys_socketcall)
+POST(sys_socketcall)
{
switch (arg1 /* request */) {
@@ -5455,5 +5452,5 @@ POSTx(sys_socketcall)
}
-PREx(sys_newstat, 0)
+PRE(sys_newstat, 0)
{
PRINT("sys_newstat ( %p(%s), %p )", arg1,arg1,arg2);
@@ -5463,10 +5460,10 @@ PREx(sys_newstat, 0)
}
-POSTx(sys_newstat)
+POST(sys_newstat)
{
POST_MEM_WRITE( arg2, sizeof(struct vki_stat) );
}
-PREx(sys_statfs, 0)
+PRE(sys_statfs, 0)
{
PRINT("sys_statfs ( %p, %p )",arg1,arg2);
@@ -5476,10 +5473,10 @@ PREx(sys_statfs, 0)
}
-POSTx(sys_statfs)
+POST(sys_statfs)
{
POST_MEM_WRITE( arg2, sizeof(struct vki_statfs) );
}
-PREx(sys_statfs64, 0)
+PRE(sys_statfs64, 0)
{
PRINT("sys_statfs64 ( %p, %llu, %p )",arg1,(ULong)arg2,arg3);
@@ -5490,10 +5487,10 @@ PREx(sys_statfs64, 0)
}
-POSTx(sys_statfs64)
+POST(sys_statfs64)
{
POST_MEM_WRITE( arg3, arg2 );
}
-PREx(sys_symlink, MayBlock)
+PRE(sys_symlink, MayBlock)
{
PRINT("sys_symlink ( %p, %p )",arg1,arg2);
@@ -5503,5 +5500,5 @@ PREx(sys_symlink, MayBlock)
}
-PREx(sys_stat64, 0)
+PRE(sys_stat64, 0)
{
PRINT("sys_stat64 ( %p, %p )",arg1,arg2);
@@ -5511,10 +5508,10 @@ PREx(sys_stat64, 0)
}
-POSTx(sys_stat64)
+POST(sys_stat64)
{
POST_MEM_WRITE( arg2, sizeof(struct vki_stat64) );
}
-PREx(sys_fstat64, 0)
+PRE(sys_fstat64, 0)
{
PRINT("sys_fstat64 ( %d, %p )",arg1,arg2);
@@ -5523,10 +5520,10 @@ PREx(sys_fstat64, 0)
}
-POSTx(sys_fstat64)
+POST(sys_fstat64)
{
POST_MEM_WRITE( arg2, sizeof(struct vki_stat64) );
}
-PREx(sys_sysinfo, 0)
+PRE(sys_sysinfo, 0)
{
PRINT("sys_sysinfo ( %p )",arg1);
@@ -5535,10 +5532,10 @@ PREx(sys_sysinfo, 0)
}
-POSTx(sys_sysinfo)
+POST(sys_sysinfo)
{
POST_MEM_WRITE( arg1, sizeof(struct vki_sysinfo) );
}
-PREx(sys_time, 0)
+PRE(sys_time, 0)
{
/* time_t time(time_t *t); */
@@ -5550,5 +5547,5 @@ PREx(sys_time, 0)
}
-POSTx(sys_time)
+POST(sys_time)
{
if (arg1 != (UWord)NULL) {
@@ -5557,5 +5554,5 @@ POSTx(sys_time)
}
-PREx(sys_times, 0)
+PRE(sys_times, 0)
{
PRINT("sys_times ( %p )", arg1);
@@ -5564,5 +5561,5 @@ PREx(sys_times, 0)
}
-POSTx(sys_times)
+POST(sys_times)
{
if (arg1 != (UWord)NULL) {
@@ -5571,5 +5568,5 @@ POSTx(sys_times)
}
-PREx(sys_umask, 0)
+PRE(sys_umask, 0)
{
PRINT("sys_umask ( %d )", arg1);
@@ -5577,5 +5574,5 @@ PREx(sys_umask, 0)
}
-PREx(sys_unlink, MayBlock)
+PRE(sys_unlink, MayBlock)
{
PRINT("sys_unlink ( %p(%s) )", arg1,arg1);
@@ -5584,5 +5581,5 @@ PREx(sys_unlink, MayBlock)
}
-PREx(sys_newuname, 0)
+PRE(sys_newuname, 0)
{
PRINT("sys_newuname ( %p )", arg1);
@@ -5591,5 +5588,5 @@ PREx(sys_newuname, 0)
}
-POSTx(sys_newuname)
+POST(sys_newuname)
{
if (arg1 != (UWord)NULL) {
@@ -5598,5 +5595,5 @@ POSTx(sys_newuname)
}
-PREx(sys_utime, MayBlock)
+PRE(sys_utime, MayBlock)
{
PRINT("sys_utime ( %p, %p )", arg1,arg2);
@@ -5607,5 +5604,5 @@ PREx(sys_utime, MayBlock)
}
-PREx(sys_waitpid, MayBlock)
+PRE(sys_waitpid, MayBlock)
{
PRINT("sys_waitpid ( %d, %p, %d )", arg1,arg2,arg3);
@@ -5617,5 +5614,5 @@ PREx(sys_waitpid, MayBlock)
}
-POSTx(sys_waitpid)
+POST(sys_waitpid)
{
if (arg2 != (Addr)NULL)
@@ -5623,5 +5620,5 @@ POSTx(sys_waitpid)
}
-PREx(sys_wait4, MayBlock)
+PRE(sys_wait4, MayBlock)
{
PRINT("sys_wait4 ( %d, %p, %d, %p )", arg1,arg2,arg3,arg4);
@@ -5637,5 +5634,5 @@ PREx(sys_wait4, MayBlock)
}
-POSTx(sys_wait4)
+POST(sys_wait4)
{
if (arg2 != (Addr)NULL)
@@ -5645,5 +5642,5 @@ POSTx(sys_wait4)
}
-PREx(sys_writev, MayBlock)
+PRE(sys_writev, MayBlock)
{
Int i;
@@ -5668,5 +5665,5 @@ PREx(sys_writev, MayBlock)
}
-PREx(sys_prctl, MayBlock)
+PRE(sys_prctl, MayBlock)
{
PRINT( "prctl ( %d, %d, %d, %d, %d )", arg1, arg2, arg3, arg4, arg5 );
@@ -5680,5 +5677,5 @@ PREx(sys_prctl, MayBlock)
}
-PREx(sys_adjtimex, 0)
+PRE(sys_adjtimex, 0)
{
struct vki_timex *tx = (struct vki_timex *)arg1;
@@ -5702,10 +5699,10 @@ PREx(sys_adjtimex, 0)
}
-POSTx(sys_adjtimex)
+POST(sys_adjtimex)
{
VG_TRACK(post_mem_write, arg1, sizeof(struct vki_timex));
}
-PREx(sys_utimes, 0)
+PRE(sys_utimes, 0)
{
PRINT("sys_utimes ( %p, %p )", arg1,arg2);
@@ -5716,5 +5713,5 @@ PREx(sys_utimes, 0)
}
-PREx(sys_futex, MayBlock)
+PRE(sys_futex, MayBlock)
{
PRINT("sys_futex ( %p, %d, %d, %p, %p )", arg1,arg2,arg3,arg4,arg5);
@@ -5729,5 +5726,5 @@ PREx(sys_futex, MayBlock)
}
-POSTx(sys_futex)
+POST(sys_futex)
{
POST_MEM_WRITE( arg1, sizeof(int) );
@@ -5743,5 +5740,5 @@ POSTx(sys_futex)
}
-PREx(sys_sched_setaffinity, 0)
+PRE(sys_sched_setaffinity, 0)
{
PRINT("sched_setaffinity ( %d, %d, %p )", arg1, arg2, arg3);
@@ -5751,5 +5748,5 @@ PREx(sys_sched_setaffinity, 0)
}
-PREx(sys_sched_getaffinity, 0)
+PRE(sys_sched_getaffinity, 0)
{
PRINT("sched_getaffinity ( %d, %d, %p )", arg1, arg2, arg3);
@@ -5759,10 +5756,10 @@ PREx(sys_sched_getaffinity, 0)
}
-POSTx(sys_sched_getaffinity)
+POST(sys_sched_getaffinity)
{
VG_TRACK(post_mem_write, arg3, arg2);
}
-PREx(sys_acct, 0)
+PRE(sys_acct, 0)
{
PRINT("sys_acct ( %p )", arg1);
@@ -5771,5 +5768,5 @@ PREx(sys_acct, 0)
}
-PREx(sys_pause, MayBlock)
+PRE(sys_pause, MayBlock)
{
PRINT("sys_pause ( )");
@@ -5778,5 +5775,5 @@ PREx(sys_pause, MayBlock)
// XXX: x86-specific
-PREx(sys_sigsuspend, MayBlock)
+PRE(sys_sigsuspend, MayBlock)
{
/* The C library interface to sigsuspend just takes a pointer to
@@ -5796,5 +5793,5 @@ PREx(sys_sigsuspend, MayBlock)
// XXX: x86-specific
-PREx(sys_rt_sigsuspend, MayBlock)
+PRE(sys_rt_sigsuspend, MayBlock)
{
/* The C library interface to sigsuspend just takes a pointer to
@@ -5811,5 +5808,5 @@ PREx(sys_rt_sigsuspend, MayBlock)
}
-PREx(sys_rt_sigtimedwait, MayBlock)
+PRE(sys_rt_sigtimedwait, MayBlock)
{
PRINT("sys_rt_sigtimedwait ( %p, %p, %p, %lld )",
@@ -5826,5 +5823,5 @@ PREx(sys_rt_sigtimedwait, MayBlock)
}
-POSTx(sys_rt_sigtimedwait)
+POST(sys_rt_sigtimedwait)
{
if (arg2 != (UWord)NULL)
@@ -5832,5 +5829,5 @@ POSTx(sys_rt_sigtimedwait)
}
-PREx(sys_rt_sigqueueinfo, 0)
+PRE(sys_rt_sigqueueinfo, 0)
{
PRINT("sys_rt_sigqueueinfo(%d, %d, %p)", arg1, arg2, arg3);
@@ -5841,5 +5838,5 @@ PREx(sys_rt_sigqueueinfo, 0)
}
-POSTx(sys_rt_sigqueueinfo)
+POST(sys_rt_sigqueueinfo)
{
if (res >= 0 &&
@@ -5861,5 +5858,5 @@ POSTx(sys_rt_sigqueueinfo)
// XXX: x86-specific
-PREx(sys_sigaltstack, SIG_SIM)
+PRE(sys_sigaltstack, SIG_SIM)
{
/* int sigaltstack(const stack_t *ss, stack_t *oss); */
@@ -5878,5 +5875,5 @@ PREx(sys_sigaltstack, SIG_SIM)
}
-POSTx(sys_sigaltstack)
+POST(sys_sigaltstack)
{
if (res == 0 && arg2 != (UWord)NULL)
@@ -5885,5 +5882,5 @@ POSTx(sys_sigaltstack)
// XXX: x86-specific
-PREx(sys_sigaction, SIG_SIM)
+PRE(sys_sigaction, SIG_SIM)
{
PRINT("sys_sigaction ( %d, %p, %p )", arg1,arg2,arg3);
@@ -5900,5 +5897,5 @@ PREx(sys_sigaction, SIG_SIM)
}
-POSTx(sys_sigaction)
+POST(sys_sigaction)
{
if (res == 0 && arg3 != (UWord)NULL)
@@ -5907,11 +5904,10 @@ POSTx(sys_sigaction)
// XXX: x86-specific
-PREx(sys_rt_sigaction, SIG_SIM)
+PRE(sys_rt_sigaction, SIG_SIM)
{
PRINT("sys_rt_sigaction ( %d, %p, %p, %d )", arg1,arg2,arg3,arg4);
PRE_REG_READ4(long, "rt_sigaction",
int, signum, const struct sigaction *, act,
- struct sigaction *, oldact,
- vki_size_t, sigsetsize);
+ struct sigaction *, oldact, vki_size_t, sigsetsize);
if (arg2 != (UWord)NULL)
@@ -5925,5 +5921,5 @@ PREx(sys_rt_sigaction, SIG_SIM)
}
-POSTx(sys_rt_sigaction)
+POST(sys_rt_sigaction)
{
if (res == 0 && arg3 != (UWord)NULL)
@@ -5931,5 +5927,5 @@ POSTx(sys_rt_sigaction)
}
-PREx(sys_sigprocmask, SIG_SIM)
+PRE(sys_sigprocmask, SIG_SIM)
{
PRINT("sys_sigprocmask ( %d, %p, %p )",arg1,arg2,arg3);
@@ -5962,5 +5958,5 @@ PREx(sys_sigprocmask, SIG_SIM)
}
-POSTx(sys_sigprocmask)
+POST(sys_sigprocmask)
{
if (res == 0 && arg3 != (UWord)NULL)
@@ -5968,5 +5964,5 @@ POSTx(sys_sigprocmask)
}
-PREx(sys_rt_sigprocmask, SIG_SIM)
+PRE(sys_rt_sigprocmask, SIG_SIM)
{
PRINT("sys_rt_sigprocmask ( %d, %p, %p, %llu )",arg1,arg2,arg3,(ULong)arg4);
@@ -5989,5 +5985,5 @@ PREx(sys_rt_sigprocmask, SIG_SIM)
}
-POSTx(sys_rt_sigprocmask)
+POST(sys_rt_sigprocmask)
{
if (res == 0 && arg3 != (UWord)NULL)
@@ -5995,5 +5991,5 @@ POSTx(sys_rt_sigprocmask)
}
-PREx(sys_sigpending, NBRunInLWP)
+PRE(sys_sigpending, NBRunInLWP)
{
PRINT( "sys_sigpending ( %p )", arg1 );
@@ -6002,10 +5998,10 @@ PREx(sys_sigpending, NBRunInLWP)
}
-POSTx(sys_sigpending)
+POST(sys_sigpending)
{
POST_MEM_WRITE( arg1, sizeof(vki_old_sigset_t) ) ;
}
-PREx(sys_rt_sigpending, NBRunInLWP)
+PRE(sys_rt_sigpending, NBRunInLWP)
{
PRINT( "sys_rt_sigpending ( %p )", arg1 );
@@ -6015,5 +6011,5 @@ PREx(sys_rt_sigpending, NBRunInLWP)
}
-POSTx(sys_rt_sigpending)
+POST(sys_rt_sigpending)
{
POST_MEM_WRITE( arg1, sizeof(vki_sigset_t) ) ;
@@ -6023,5 +6019,5 @@ POSTx(sys_rt_sigpending)
// the syscall itself, and this allows us to control exactly the code that
// gets run while the padding is in place.
-PREx(sys_io_setup, Special)
+PRE(sys_io_setup, Special)
{
SizeT size;
@@ -6061,5 +6057,5 @@ PREx(sys_io_setup, Special)
// know that we must look at the aio_ring structure because Tom inspected the
// kernel and glibc sources to see what they do, yuk.)
-PREx(sys_io_destroy, Special)
+PRE(sys_io_destroy, Special)
{
Segment *s = VG_(find_segment)(arg1);
@@ -6084,5 +6080,5 @@ PREx(sys_io_destroy, Special)
}
-PREx(sys_io_getevents, MayBlock)
+PRE(sys_io_getevents, MayBlock)
{
PRINT("sys_io_getevents ( %llu, %lld, %lld, %p, %p )",
@@ -6100,5 +6096,5 @@ PREx(sys_io_getevents, MayBlock)
}
-POSTx(sys_io_getevents)
+POST(sys_io_getevents)
{
int i;
@@ -6127,5 +6123,5 @@ POSTx(sys_io_getevents)
}
-PREx(sys_io_submit, 0)
+PRE(sys_io_submit, 0)
{
int i;
@@ -6158,5 +6154,5 @@ PREx(sys_io_submit, 0)
}
-PREx(sys_io_cancel, 0)
+PRE(sys_io_cancel, 0)
{
PRINT("sys_io_cancel( %llu, %p, %p )", (ULong)arg1,arg2,arg3);
@@ -6168,10 +6164,10 @@ PREx(sys_io_cancel, 0)
}
-POSTx(sys_io_cancel)
+POST(sys_io_cancel)
{
POST_MEM_WRITE( arg3, sizeof(struct vki_io_event) );
}
-PREx(sys_mq_open, 0)
+PRE(sys_mq_open, 0)
{
PRINT("sys_mq_open( %p(%s), %d, %lld, %p )",
@@ -6190,5 +6186,5 @@ PREx(sys_mq_open, 0)
}
-POSTx(sys_mq_open)
+POST(sys_mq_open)
{
if (!fd_allowed(res, "mq_open", tid, True)) {
@@ -6201,5 +6197,5 @@ POSTx(sys_mq_open)
}
-PREx(sys_mq_unlink, 0)
+PRE(sys_mq_unlink, 0)
{
PRINT("sys_mq_unlink ( %p(%s) )", arg1,arg1);
@@ -6208,5 +6204,5 @@ PREx(sys_mq_unlink, 0)
}
-PREx(sys_mq_timedsend, MayBlock)
+PRE(sys_mq_timedsend, MayBlock)
{
PRINT("sys_mq_timedsend ( %d, %p, %llu, %d, %p )",
@@ -6225,5 +6221,5 @@ PREx(sys_mq_timedsend, MayBlock)
}
-PREx(sys_mq_timedreceive, MayBlock)
+PRE(sys_mq_timedreceive, MayBlock)
{
PRINT("sys_mq_timedreceive( %d, %p, %llu, %p, %p )",
@@ -6246,5 +6242,5 @@ PREx(sys_mq_timedreceive, MayBlock)
}
-POSTx(sys_mq_timedreceive)
+POST(sys_mq_timedreceive)
{
POST_MEM_WRITE( arg2, arg3 );
@@ -6253,5 +6249,5 @@ POSTx(sys_mq_timedreceive)
}
-PREx(sys_mq_notify, 0)
+PRE(sys_mq_notify, 0)
{
PRINT("sys_mq_notify( %d, %p )", arg1,arg2 );
@@ -6265,5 +6261,5 @@ PREx(sys_mq_notify, 0)
}
-PREx(sys_mq_getsetattr, 0)
+PRE(sys_mq_getsetattr, 0)
{
PRINT("sys_mq_getsetattr( %d, %p, %p )", arg1,arg2,arg3 );
@@ -6285,5 +6281,5 @@ PREx(sys_mq_getsetattr, 0)
}
-POSTx(sys_mq_getsetattr)
+POST(sys_mq_getsetattr)
{
if (arg3 != 0)
@@ -6291,5 +6287,5 @@ POSTx(sys_mq_getsetattr)
}
-PREx(sys_timer_create, 0)
+PRE(sys_timer_create, 0)
{
PRINT("sys_timer_create( %d, %p, %p )", arg1,arg2,arg3);
@@ -6302,10 +6298,10 @@ PREx(sys_timer_create, 0)
}
-POSTx(sys_timer_create)
+POST(sys_timer_create)
{
POST_MEM_WRITE( arg3, sizeof(vki_timer_t) );
}
-PREx(sys_timer_settime, 0)
+PRE(sys_timer_settime, 0)
{
PRINT("sys_timer_settime( %lld, %d, %p, %p )", (ULong)arg1,arg2,arg3,arg4);
@@ -6321,5 +6317,5 @@ PREx(sys_timer_settime, 0)
}
-POSTx(sys_timer_settime)
+POST(sys_timer_settime)
{
if (arg4 != 0)
@@ -6327,5 +6323,5 @@ POSTx(sys_timer_settime)
}
-PREx(sys_timer_gettime, 0)
+PRE(sys_timer_gettime, 0)
{
PRINT("sys_timer_gettime( %lld, %p )", (ULong)arg1,arg2);
@@ -6336,10 +6332,10 @@ PREx(sys_timer_gettime, 0)
}
-POSTx(sys_timer_gettime)
+POST(sys_timer_gettime)
{
POST_MEM_WRITE( arg2, sizeof(struct vki_itimerspec) );
}
-PREx(sys_timer_getoverrun, 0)
+PRE(sys_timer_getoverrun, 0)
{
PRINT("sys_timer_getoverrun( %p )", arg1);
@@ -6347,5 +6343,5 @@ PREx(sys_timer_getoverrun, 0)
}
-PREx(sys_timer_delete, 0)
+PRE(sys_timer_delete, 0)
{
PRINT("sys_timer_delete( %p )", arg1);
@@ -6353,5 +6349,5 @@ PREx(sys_timer_delete, 0)
}
-PREx(sys_clock_settime, 0)
+PRE(sys_clock_settime, 0)
{
PRINT("sys_clock_settime( %d, %p )", arg1,arg2);
@@ -6361,5 +6357,5 @@ PREx(sys_clock_settime, 0)
}
-PREx(sys_clock_gettime, 0)
+PRE(sys_clock_gettime, 0)
{
PRINT("sys_clock_gettime( %d, %p )" , arg1,arg2);
@@ -6369,10 +6365,10 @@ PREx(sys_clock_gettime, 0)
}
-POSTx(sys_clock_gettime)
+POST(sys_clock_gettime)
{
POST_MEM_WRITE( arg2, sizeof(struct vki_timespec) );
}
-PREx(sys_clock_getres, 0)
+PRE(sys_clock_getres, 0)
{
PRINT("sys_clock_getres( %d, %p )" , arg1,arg2);
@@ -6384,5 +6380,5 @@ PREx(sys_clock_getres, 0)
}
-POSTx(sys_clock_getres)
+POST(sys_clock_getres)
{
POST_MEM_WRITE( arg2, sizeof(struct vki_timespec) );
@@ -6407,22 +6403,17 @@ POSTx(sys_clock_getres)
from the __NR_foo constants to the sys_foo() PRE/POST wrappers above.
- XXX: doing this in stages, so we're in transition between the old
- SYSB_/SYSBA macros to the new SYSX_/SYS_XY macros.
-
XXX: some of these are arch-specific, and should be factored out.
*/
struct sys_info {
- UInt flags; // XXX: remove this once every syscall has been converted
UInt *flags_ptr;
void (*before)(ThreadId tid, ThreadState *tst);
void (*after) (ThreadId tid, ThreadState *tst);
};
-#define SYSB_(name, n2, flags) [name] = { flags, NULL, before_##name, NULL }
-#define SYSBA(name, n2, flags) [name] = { flags, NULL, before_##name, after_##name }
-#define SYSX_(const, name) [const] = { 0, &flags_##name, before_##name, NULL }
-#define SYSXY(const, name) [const] = { 0, &flags_##name, before_##name, after_##name }
+#define SYSX_(const, name) [const] = { &flags_##name, before_##name, NULL }
+#define SYSXY(const, name) [const] = { &flags_##name, before_##name, after_##name }
+static UInt bad_flags = Special;
static void bad_before(ThreadId tid, ThreadState *tst)
{
@@ -6441,5 +6432,5 @@ static void bad_before(ThreadId tid, Thr
}
-static const struct sys_info bad_sys = { Special, NULL, bad_before, NULL };
+static const struct sys_info bad_sys = { &bad_flags, bad_before, NULL };
// XXX: temporary: I've started labelled each entry with the target of its
@@ -6728,6 +6719,4 @@ static const struct sys_info sys_info[]
SYSXY(__NR_getdents64, sys_getdents64), // 220 * (SVr4,SVID?)
- // XXX: This wrapped in a "#if BITS_PER_LONG == 32" in
- // include/linux/syscalls.h...
SYSXY(__NR_fcntl64, sys_fcntl64), // 221 * P?
// Nb: 222 is reserved for TUX (whatever that means --njn)
@@ -6810,7 +6799,4 @@ static const struct sys_info sys_info[]
#define MAX_SYS_INFO (sizeof(sys_info)/sizeof(sys_info[0]))
-#undef SYSB_
-#undef SYSBA
-
#undef SYSX_
#undef SYSXY
@@ -6872,10 +6858,5 @@ Bool VG_(pre_syscall) ( ThreadId tid )
sys = &bad_sys;
}
- // XXX: remove once all syscalls are converted
- if (sys->flags_ptr) {
flags = *(sys->flags_ptr);
- } else {
- flags = sys->flags;
- }
{
@@ -6987,10 +6968,5 @@ void VG_(post_syscall) ( ThreadId tid, B
sys = &bad_sys;
}
- // XXX: remove once all syscalls are converted
- if (sys->flags_ptr) {
flags = *(sys->flags_ptr);
- } else {
- flags = sys->flags;
- }
isSpecial = flags & Special;
|