From: Nicholas Nethercote Date: Tue, 16 Nov 2004 16:15:41 +0000 (+0000) Subject: Converted the timer_* and clock_* syscalls. X-Git-Tag: svn/VALGRIND_3_0_0~1290 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=126c196c210c7fa1f5b88a88e8ac5c0bee3790d8;p=thirdparty%2Fvalgrind.git Converted the timer_* and clock_* syscalls. Also now checking the return value of every syscall in scalar, to make sure that they (mostly) fail as expected. Because occasionally one would succeed unexpectedly and unaddressable memory would be marked as addressable, and things would go haywire. (The fact that the wrapper sets the memory as addressable in these cases is a bug with the relevant wrappers; I'll fix them later.) git-svn-id: svn://svn.valgrind.org/valgrind/trunk@3023 --- diff --git a/coregrind/vg_syscalls.c b/coregrind/vg_syscalls.c index ae4d3b33cd..0e7899f869 100644 --- a/coregrind/vg_syscalls.c +++ b/coregrind/vg_syscalls.c @@ -1055,14 +1055,21 @@ static Bool fd_allowed(Int fd, const Char *syscallname, ThreadId tid, Bool soft) comment for sys_info[] and related arrays for important info about the __NR_foo constants and their relationship to the sys_foo() functions. - Note that for the PRE_REG_READ tests, we pass a somewhat generic name - for the syscall (eg. "write")... this should be good enough for the - average user to understand what is happening, without confusing them - with names like "sys_write". Also, the arg names sometimes are taken - from the man pages for the glibc equivalent functions, rather than those - used in the Linux source code, for the same reason. However, for the - --trace-syscalls=yes output, we use the sys_foo() name to avoid - ambiguity. + Some notes about names used for syscalls and args: + - For the --trace-syscalls=yes output, we use the sys_foo() name to avoid + ambiguity. + + - For error messages, we generally use a somewhat generic name + for the syscall (eg. "write" rather than "sys_write"). This should be + good enough for the average user to understand what is happening, + without confusing them with names like "sys_write". + + - Also, for error messages the arg names are mostly taken from the man + pages (even though many of those man pages are really for glibc + functions of the same name), rather than from the Linux kernel source, + for the same reason -- a user presented with a "bogus foo(bar)" arg + will most likely look at the "foo" man page to see which is the "bar" + arg. Note that we use our own vki_* types. The one exception is in PRE_REG_READn calls, where pointer types haven't been changed, because @@ -5823,15 +5830,16 @@ POSTx(sys_rt_sigtimedwait) POST_MEM_WRITE( arg2, sizeof(vki_siginfo_t) ); } -PRE(rt_sigqueueinfo) +PREx(sys_rt_sigqueueinfo, 0) { - /* long sys_rt_sigqueueinfo(int pid, int sig, siginfo_t *uinfo) */ - PRINT("rt_sigqueueinfo(%d, %d, %p)", arg1, arg2, arg3); + PRINT("sys_rt_sigqueueinfo(%d, %d, %p)", arg1, arg2, arg3); + PRE_REG_READ3(long, "rt_sigqueueinfo", + int, pid, int, sig, vki_siginfo_t *, uinfo); if (arg2 != (UWord)NULL) - PRE_MEM_READ( "sigqueueinfo(uinfo)", arg3, sizeof(vki_siginfo_t) ); + PRE_MEM_READ( "rt_sigqueueinfo(uinfo)", arg3, sizeof(vki_siginfo_t) ); } -POST(rt_sigqueueinfo) +POSTx(sys_rt_sigqueueinfo) { if (res >= 0 && arg2 != 0 && @@ -6278,27 +6286,29 @@ POSTx(sys_mq_getsetattr) POST_MEM_WRITE( arg3, sizeof(struct vki_mq_attr) ); } -PRE(timer_create) +PREx(sys_timer_create, 0) { - /* int timer_create(clockid_t clock_id, struct sigevent *restrict evp, - timer_t *restrict timerid); */ - PRINT("timer_create( %d, %p, %p )", arg1,arg2,arg3); + PRINT("sys_timer_create( %d, %p, %p )", arg1,arg2,arg3); + PRE_REG_READ3(long, "timer_create", + vki_clockid_t, clockid, struct sigevent *, evp, + vki_timer_t *, timerid); if (arg2 != 0) 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) +POSTx(sys_timer_create) { POST_MEM_WRITE( arg3, sizeof(vki_timer_t) ); } -PRE(timer_settime) +PREx(sys_timer_settime, 0) { - /* int timer_settime(timer_t timerid, int flags, - const struct itimerspec *restrict value, - struct itimerspec *restrict ovalue); */ - PRINT("timer_settime( %p, %d, %p, %p )", arg1,arg2,arg3,arg4); + PRINT("sys_timer_settime( %lld, %d, %p, %p )", (ULong)arg1,arg2,arg3,arg4); + PRE_REG_READ4(long, "timer_settime", + vki_timer_t, timerid, int, flags, + const struct itimerspec *, value, + struct itimerspec *, ovalue); PRE_MEM_READ( "timer_settime(value)", arg3, sizeof(struct vki_itimerspec) ); if (arg4 != 0) @@ -6306,66 +6316,72 @@ PRE(timer_settime) sizeof(struct vki_itimerspec) ); } -POST(timer_settime) +POSTx(sys_timer_settime) { if (arg4 != 0) POST_MEM_WRITE( arg4, sizeof(struct vki_itimerspec) ); } -PRE(timer_gettime) +PREx(sys_timer_gettime, 0) { - /* int timer_gettime(timer_t timerid, struct itimerspec *value); */ - PRINT("timer_gettime( %p, %p )", arg1,arg2); + PRINT("sys_timer_gettime( %lld, %p )", (ULong)arg1,arg2); + PRE_REG_READ2(long, "timer_gettime", + vki_timer_t, timerid, struct itimerspec *, value); PRE_MEM_WRITE( "timer_gettime(value)", arg2, sizeof(struct vki_itimerspec)); } -POST(timer_gettime) +POSTx(sys_timer_gettime) { POST_MEM_WRITE( arg2, sizeof(struct vki_itimerspec) ); } -PRE(timer_getoverrun) +PREx(sys_timer_getoverrun, 0) { - /* int timer_getoverrun(timer_t timerid); */ - PRINT("timer_getoverrun( %p )", arg1); + PRINT("sys_timer_getoverrun( %p )", arg1); + PRE_REG_READ1(long, "timer_getoverrun", vki_timer_t, timerid); } -PRE(timer_delete) +PREx(sys_timer_delete, 0) { - /* int timer_delete(timer_t timerid); */ - PRINT("timer_delete( %p )", arg1); + PRINT("sys_timer_delete( %p )", arg1); + PRE_REG_READ1(long, "timer_delete", vki_timer_t, timerid); } -PRE(clock_settime) +PREx(sys_clock_settime, 0) { - /* int clock_settime(clockid_t clk_id, const struct timespec *tp); */ - PRINT("clock_settime( %d, %p )", arg1,arg2); - PRE_MEM_READ( "clock_gettime(tp)", arg2, sizeof(struct vki_timespec) ); + PRINT("sys_clock_settime( %d, %p )", arg1,arg2); + PRE_REG_READ2(long, "clock_settime", + vki_clockid_t, clk_id, const struct timespec *, tp); + PRE_MEM_READ( "clock_settime(tp)", arg2, sizeof(struct vki_timespec) ); } -PRE(clock_gettime) +PREx(sys_clock_gettime, 0) { - /* int clock_gettime(clockid_t clk_id, struct timespec *tp); */ - PRINT("clock_gettime( %d, %p )" , arg1,arg2); - PRE_MEM_WRITE( "clock_gettime(tp)", arg2, sizeof(struct vki_timespec) ); + PRINT("sys_clock_gettime( %d, %p )" , arg1,arg2); + PRE_REG_READ2(long, "clock_gettime", + vki_clockid_t, clk_id, struct timespec *, tp); + PRE_MEM_WRITE( "clock_gettime(tp)", arg2, sizeof(struct vki_timespec) ); } -POST(clock_gettime) +POSTx(sys_clock_gettime) { - POST_MEM_WRITE( arg2, sizeof(struct vki_timespec) ); + POST_MEM_WRITE( arg2, sizeof(struct vki_timespec) ); } -PRE(clock_getres) +PREx(sys_clock_getres, 0) { - /* int clock_getres(clockid_t clk_id, struct timespec *res); */ - PRINT("clock_getres( %d, %p )" , arg1,arg2); - PRE_MEM_WRITE( "clock_getres(res)", arg2, sizeof(struct vki_timespec) ); + PRINT("sys_clock_getres( %d, %p )" , arg1,arg2); + // Nb: we can't use "res" as the param name because that's a macro + // defined above! + PRE_REG_READ2(long, "clock_getres", + vki_clockid_t, clk_id, struct timespec *, cres); + PRE_MEM_WRITE( "clock_getres(cres)", arg2, sizeof(struct vki_timespec) ); } -POST(clock_getres) +POSTx(sys_clock_getres) { - POST_MEM_WRITE( arg2, sizeof(struct vki_timespec) ); + POST_MEM_WRITE( arg2, sizeof(struct vki_timespec) ); } @@ -6654,7 +6670,7 @@ static const struct sys_info sys_info[] = { SYSXY(__NR_rt_sigprocmask, sys_rt_sigprocmask), // 175 * ? SYSXY(__NR_rt_sigpending, sys_rt_sigpending), // 176 * ? SYSXY(__NR_rt_sigtimedwait, sys_rt_sigtimedwait), // 177 * ? - SYSBA(__NR_rt_sigqueueinfo, sys_rt_sigqueueinfo, 0), // 178 * + SYSXY(__NR_rt_sigqueueinfo, sys_rt_sigqueueinfo), // 178 * ? SYSX_(__NR_rt_sigsuspend, sys_rt_sigsuspend), // 179 () () SYSXY(__NR_pread64, sys_pread64), // 180 * (Unix98?) @@ -6733,9 +6749,9 @@ static const struct sys_info sys_info[] = { // (__NR_tkill, sys_tkill), // 238 * L SYSXY(__NR_sendfile64, sys_sendfile64), // 239 * L - SYSXY(__NR_futex, sys_futex), // 240 * L - SYSX_(__NR_sched_setaffinity,sys_sched_setaffinity), // 241 * L? - SYSXY(__NR_sched_getaffinity,sys_sched_getaffinity), // 242 * L? + SYSXY(__NR_futex, sys_futex), // 240 * L + SYSX_(__NR_sched_setaffinity,sys_sched_setaffinity), // 241 * L? + SYSXY(__NR_sched_getaffinity,sys_sched_getaffinity), // 242 * L? SYSB_(__NR_set_thread_area, sys_set_thread_area, Special), // 243 SYSB_(__NR_get_thread_area, sys_get_thread_area, Special), // 244 @@ -6753,19 +6769,19 @@ static const struct sys_info sys_info[] = { SYSX_(__NR_epoll_ctl, sys_epoll_ctl), // 255 * L SYSXY(__NR_epoll_wait, sys_epoll_wait), // 256 * L - // (__NR_remap_file_pages, sys_remap_file_pages), // 257 * L + // (__NR_remap_file_pages, sys_remap_file_pages),// 257 * L SYSX_(__NR_set_tid_address, sys_set_tid_address), // 258 * ? - SYSBA(__NR_timer_create, sys_timer_create, 0), // 259 + SYSXY(__NR_timer_create, sys_timer_create), // 259 (?) P - SYSBA(__NR_timer_settime, sys_timer_settime, 0), // (timer_create+1) * - SYSBA(__NR_timer_gettime, sys_timer_gettime, 0), // (timer_create+2) * - SYSB_(__NR_timer_getoverrun, sys_timer_getoverrun, 0), // (timer_create+3) * - SYSB_(__NR_timer_delete, sys_timer_delete, 0), // (timer_create+4) * - SYSB_(__NR_clock_settime, sys_clock_settime, 0), // (timer_create+5) * + SYSXY(__NR_timer_settime, sys_timer_settime), // (timer_create+1) * P + SYSXY(__NR_timer_gettime, sys_timer_gettime), // (timer_create+2) * P + SYSX_(__NR_timer_getoverrun, sys_timer_getoverrun),// (timer_create+3) * P + SYSX_(__NR_timer_delete, sys_timer_delete), // (timer_create+4) * P + SYSX_(__NR_clock_settime, sys_clock_settime), // (timer_create+5) * P - SYSBA(__NR_clock_gettime, sys_clock_gettime, 0), // (timer_create+6) * - SYSBA(__NR_clock_getres, sys_clock_getres, 0), // (timer_create+7) * - // (__NR_clock_nanosleep, sys_clock_nanosleep), // (timer_create+8) * P? + SYSXY(__NR_clock_gettime, sys_clock_gettime), // (timer_create+6) * P + SYSXY(__NR_clock_getres, sys_clock_getres), // (timer_create+7) * P + // (__NR_clock_nanosleep, sys_clock_nanosleep), // (timer_create+8) * P SYSXY(__NR_statfs64, sys_statfs64), // 268 * (?) SYSXY(__NR_fstatfs64, sys_fstatfs64), // 269 * (?) diff --git a/include/linux/vki.h b/include/linux/vki.h index 067dd5f27e..5c34bdd6ed 100644 --- a/include/linux/vki.h +++ b/include/linux/vki.h @@ -113,6 +113,7 @@ typedef __vki_kernel_pid_t vki_pid_t; typedef __vki_kernel_key_t vki_key_t; typedef __vki_kernel_suseconds_t vki_suseconds_t; typedef __vki_kernel_timer_t vki_timer_t; +typedef __vki_kernel_clockid_t vki_clockid_t; typedef __vki_kernel_mqd_t vki_mqd_t; // [[Nb: it's a bit unclear due to a #ifdef, but I think this is right. --njn]] diff --git a/include/x86-linux/vki_arch_posixtypes.h b/include/x86-linux/vki_arch_posixtypes.h index 1961bbbcad..5bc6a76782 100644 --- a/include/x86-linux/vki_arch_posixtypes.h +++ b/include/x86-linux/vki_arch_posixtypes.h @@ -47,6 +47,7 @@ typedef long __vki_kernel_time_t; typedef long __vki_kernel_suseconds_t; typedef long __vki_kernel_clock_t; typedef int __vki_kernel_timer_t; +typedef int __vki_kernel_clockid_t; typedef char * __vki_kernel_caddr_t; typedef unsigned int __vki_kernel_uid32_t; typedef unsigned int __vki_kernel_gid32_t; diff --git a/memcheck/tests/scalar.c b/memcheck/tests/scalar.c index 723567b44e..25665adb42 100644 --- a/memcheck/tests/scalar.c +++ b/memcheck/tests/scalar.c @@ -19,6 +19,7 @@ int main(void) // uninitialised, but we know px[0] is 0x0 long* px = malloc(sizeof(long)); long x0 = px[0]; + long res; // All __NR_xxx numbers are taken from x86 @@ -36,68 +37,70 @@ int main(void) // __NR_read 3 // Nb: here we are also getting an error from the syscall arg itself. GO(__NR_read, "1+3s 1m"); - SY(__NR_read+x0, x0, x0, x0+1); + SY(__NR_read+x0, x0, x0, x0+1); FAILx(EFAULT); // __NR_write 4 GO(__NR_write, "3s 1m"); - SY(__NR_write, x0, x0, x0+1); + SY(__NR_write, x0, x0, x0+1); FAIL; // __NR_open 5 GO(__NR_open, "(2-args) 2s 1m"); - SY(__NR_open, x0, x0, x0+1); + SY(__NR_open, x0, x0); FAIL; - GO(__NR_open, "(3-args) 1s 0m"); - SY(__NR_open, "tmp_write_file_foo", O_CREAT, x0); + // Only 1s 0m errors, because 2s 1m are ignored, being dups of the + // earlier 2-arg open call. + GO(__NR_open, "(3-args) 1s 0m"); + SY(__NR_open, x0, x0+O_CREAT, x0); FAIL; // __NR_close 6 GO(__NR_close, "1s 0m"); - SY(__NR_close, x0-1); + SY(__NR_close, x0-1); FAIL; // __NR_waitpid 7 GO(__NR_waitpid, "3s 1m"); - SY(__NR_waitpid, x0, x0+1, x0); + SY(__NR_waitpid, x0, x0+1, x0); FAIL; // __NR_creat 8 GO(__NR_creat, "2s 1m"); - SY(__NR_creat, x0, x0); + SY(__NR_creat, x0, x0); FAIL; // __NR_link 9 GO(__NR_link, "2s 2m"); - SY(__NR_link, x0, x0); + SY(__NR_link, x0, x0); FAIL; // __NR_unlink 10 GO(__NR_unlink, "1s 1m"); - SY(__NR_unlink, x0); + SY(__NR_unlink, x0); FAIL; // __NR_execve 11 // Nb: could have 3 memory errors if we pass x0+1 as the 2nd and 3rd // args, except for bug #93174. GO(__NR_execve, "3s 1m"); - SY(__NR_execve, x0, x0, x0); + SY(__NR_execve, x0, x0, x0); FAIL; // __NR_chdir 12 GO(__NR_chdir, "1s 1m"); - SY(__NR_chdir, x0); + SY(__NR_chdir, x0); FAIL; // __NR_time 13 GO(__NR_time, "1s 1m"); - SY(__NR_time, x0+1); + SY(__NR_time, x0+1); FAIL; // __NR_mknod 14 GO(__NR_mknod, "3s 1m"); - SY(__NR_mknod, x0, x0, x0); + SY(__NR_mknod, x0, x0, x0); FAIL; // __NR_chmod 15 GO(__NR_chmod, "2s 1m"); - SY(__NR_chmod, x0, x0); + SY(__NR_chmod, x0, x0); FAIL; // __NR_lchown 16 GO(__NR_lchown, "n/a"); - //SY(__NR_lchown); // (Not yet handled by Valgrind) + //SY(__NR_lchown); // (Not yet handled by Valgrind) FAIL; // __NR_break 17 GO(__NR_break, "ni"); - SY(__NR_break); + SY(__NR_break); FAIL; // __NR_oldstat 18 GO(__NR_oldstat, "n/a"); @@ -105,40 +108,40 @@ int main(void) // __NR_lseek 19 GO(__NR_lseek, "3s 0m"); - SY(__NR_lseek, x0, x0, x0); + SY(__NR_lseek, x0-1, x0, x0); FAILx(EBADF); // __NR_getpid 20 GO(__NR_getpid, "0s 0m"); - SY(__NR_getpid); + SY(__NR_getpid); SUCC; // __NR_mount 21 GO(__NR_mount, "5s 3m"); - SY(__NR_mount, x0, x0, x0, x0, x0); + SY(__NR_mount, x0, x0, x0, x0, x0); FAIL; // __NR_umount 22 GO(__NR_umount, "1s 1m"); - SY(__NR_umount, x0); + SY(__NR_umount, x0); FAIL; // __NR_setuid 23 GO(__NR_setuid, "1s 0m"); - SY(__NR_setuid, x0); + SY(__NR_setuid, x0); FAIL; // __NR_getuid 24 GO(__NR_getuid, "0s 0m"); - SY(__NR_getuid); + SY(__NR_getuid); SUCC; // __NR_stime 25 GO(__NR_stime, "n/a"); - //SY(__NR_stime); // (Not yet handled by Valgrind) + //SY(__NR_stime); // (Not yet handled by Valgrind) FAIL; // __NR_ptrace 26 // XXX: memory pointed to be arg3 is never checked... GO(__NR_ptrace, "4s 2m"); - SY(__NR_ptrace, x0+PTRACE_GETREGS, x0, x0, x0); + SY(__NR_ptrace, x0+PTRACE_GETREGS, x0, x0, x0); FAIL; // __NR_alarm 27 GO(__NR_alarm, "1s 0m"); - SY(__NR_alarm, x0); + SY(__NR_alarm, x0); SUCC; // __NR_oldfstat 28 GO(__NR_oldfstat, "n/a"); @@ -149,120 +152,120 @@ int main(void) // __NR_utime 30 GO(__NR_utime, "2s 2m"); - SY(__NR_utime, x0, x0+1); + SY(__NR_utime, x0, x0+1); FAIL; // __NR_stty 31 GO(__NR_stty, "ni"); - SY(__NR_stty); + SY(__NR_stty); FAIL; // __NR_gtty 32 GO(__NR_gtty, "ni"); - SY(__NR_gtty); + SY(__NR_gtty); FAIL; // __NR_access 33 GO(__NR_access, "2s 1m"); - SY(__NR_access, x0, x0); + SY(__NR_access, x0, x0); FAIL; // __NR_nice 34 GO(__NR_nice, "1s 0m"); - SY(__NR_nice, x0); + SY(__NR_nice, x0); SUCC; // __NR_ftime 35 GO(__NR_ftime, "ni"); - SY(__NR_ftime); + SY(__NR_ftime); FAIL; // __NR_sync 36 GO(__NR_sync, "0s 0m"); - SY(__NR_sync); + SY(__NR_sync); SUCC; // __NR_kill 37 GO(__NR_kill, "2s 0m"); - SY(__NR_kill, x0, x0); + SY(__NR_kill, x0, x0); SUCC; // __NR_rename 38 GO(__NR_rename, "2s 2m"); - SY(__NR_rename, x0, x0); + SY(__NR_rename, x0, x0); FAIL; // __NR_mkdir 39 GO(__NR_mkdir, "2s 1m"); - SY(__NR_mkdir, x0, x0); + SY(__NR_mkdir, x0, x0); FAIL; // __NR_rmdir 40 GO(__NR_rmdir, "1s 1m"); - SY(__NR_rmdir, x0); + SY(__NR_rmdir, x0); FAIL; // __NR_dup 41 GO(__NR_dup, "1s 0m"); - SY(__NR_dup, x0); + SY(__NR_dup, x0-1); FAIL; // __NR_pipe 42 GO(__NR_pipe, "1s 1m"); - SY(__NR_pipe, x0); + SY(__NR_pipe, x0); FAIL; // __NR_times 43 GO(__NR_times, "1s 1m"); - SY(__NR_times, x0); + SY(__NR_times, x0+1); FAIL; // __NR_prof 44 GO(__NR_prof, "ni"); - SY(__NR_prof); + SY(__NR_prof); FAIL; // __NR_brk 45 GO(__NR_brk, "1s 0m"); - SY(__NR_brk, x0); + SY(__NR_brk, x0); SUCC; // __NR_setgid 46 GO(__NR_setgid, "1s 0m"); - SY(__NR_setgid, x0); + SY(__NR_setgid, x0); FAIL; // __NR_getgid 47 GO(__NR_getgid, "0s 0m"); - SY(__NR_getgid); + SY(__NR_getgid); SUCC; // __NR_signal 48 GO(__NR_signal, "n/a"); - //SY(__NR_signal); // (Not yet handled by Valgrind) + //SY(__NR_signal); // (Not yet handled by Valgrind) FAIL; // __NR_geteuid 49 GO(__NR_geteuid, "0s 0m"); - SY(__NR_geteuid); + SY(__NR_geteuid); SUCC; // __NR_getegid 50 GO(__NR_getegid, "0s 0m"); - SY(__NR_getegid); + SY(__NR_getegid); SUCC; // __NR_acct 51 GO(__NR_acct, "1s 1m"); - SY(__NR_acct, x0); + SY(__NR_acct, x0); FAIL; // __NR_umount2 52 GO(__NR_umount2, "2s 1m"); - SY(__NR_umount2, x0, x0); + SY(__NR_umount2, x0, x0); FAIL; // __NR_lock 53 GO(__NR_lock, "ni"); - SY(__NR_lock); + SY(__NR_lock); FAIL; // __NR_ioctl 54 #include GO(__NR_ioctl, "3s 1m"); - SY(__NR_ioctl, x0, x0+TCSETS, x0); + SY(__NR_ioctl, x0, x0+TCSETS, x0); FAIL; // __NR_fcntl 55 GO(__NR_fcntl, "3s 0m"); - SY(__NR_fcntl, x0, x0, x0); + SY(__NR_fcntl, x0-1, x0, x0); FAIL; // __NR_mpx 56 GO(__NR_mpx, "ni"); - SY(__NR_mpx); + SY(__NR_mpx); FAIL; // __NR_setpgid 57 GO(__NR_setpgid, "2s 0m"); - SY(__NR_setpgid, x0, x0); + SY(__NR_setpgid, x0, x0-1); FAIL; // __NR_ulimit 58 GO(__NR_ulimit, "ni"); - SY(__NR_ulimit); + SY(__NR_ulimit); FAIL; // __NR_oldolduname 59 GO(__NR_oldolduname, "n/a"); @@ -270,11 +273,11 @@ int main(void) // __NR_umask 60 GO(__NR_umask, "1s 0m"); - SY(__NR_umask, x0); + SY(__NR_umask, x0+022); SUCC; // __NR_chroot 61 GO(__NR_chroot, "1s 1m"); - SY(__NR_chroot, x0); + SY(__NR_chroot, x0); FAIL; // __NR_ustat 62 GO(__NR_ustat, "n/a"); @@ -282,91 +285,91 @@ int main(void) // __NR_dup2 63 GO(__NR_dup2, "2s 0m"); - SY(__NR_dup2, x0, x0); + SY(__NR_dup2, x0-1, x0); FAIL; // __NR_getppid 64 GO(__NR_getppid, "0s 0m"); - SY(__NR_getppid); + SY(__NR_getppid); SUCC; // __NR_getpgrp 65 GO(__NR_getpgrp, "0s 0m"); - SY(__NR_getpgrp); + SY(__NR_getpgrp); SUCC; // __NR_setsid 66 GO(__NR_setsid, "0s 0m"); - SY(__NR_setsid); + SY(__NR_setsid); SUCC_OR_FAIL; // __NR_sigaction 67 GO(__NR_sigaction, "3s 2m"); - SY(__NR_sigaction, x0, x0+1, x0+1); + SY(__NR_sigaction, x0, x0+1, x0+1); FAIL; // __NR_sgetmask 68 sys_sgetmask() GO(__NR_sgetmask, "n/a"); - //SY(__NR_sgetmask); // (Not yet handled by Valgrind) + //SY(__NR_sgetmask); // (Not yet handled by Valgrind) FAIL; // __NR_ssetmask 69 GO(__NR_ssetmask, "n/a"); - //SY(__NR_ssetmask); // (Not yet handled by Valgrind) + //SY(__NR_ssetmask); // (Not yet handled by Valgrind) FAIL; // __NR_setreuid 70 GO(__NR_setreuid, "2s 0m"); - SY(__NR_setreuid, x0, x0); + SY(__NR_setreuid, x0, x0); FAIL; // __NR_setregid 71 GO(__NR_setregid, "2s 0m"); - SY(__NR_setregid, x0, x0); + SY(__NR_setregid, x0, x0); FAIL; // __NR_sigsuspend 72 // XXX: how do you use this function? // GO(__NR_sigsuspend, ".s .m"); -// SY(__NR_sigsuspend); +// SY(__NR_sigsuspend); FAIL; // __NR_sigpending 73 GO(__NR_sigpending, "1s 1m"); - SY(__NR_sigpending, x0); + SY(__NR_sigpending, x0); FAIL; // __NR_sethostname 74 GO(__NR_sethostname, "n/a"); - //SY(__NR_sethostname); // (Not yet handled by Valgrind) + //SY(__NR_sethostname); // (Not yet handled by Valgrind) FAIL; // __NR_setrlimit 75 GO(__NR_setrlimit, "2s 1m"); - SY(__NR_setrlimit, x0, x0); + SY(__NR_setrlimit, x0, x0); FAIL; // __NR_getrlimit 76 GO(__NR_getrlimit, "2s 1m"); - SY(__NR_getrlimit, x0, x0); + SY(__NR_getrlimit, x0, x0); FAIL; // __NR_getrusage 77 GO(__NR_getrusage, "2s 1m"); - SY(__NR_getrusage, x0, x0); + SY(__NR_getrusage, x0, x0); FAIL; // __NR_gettimeofday 78 GO(__NR_gettimeofday, "2s 2m"); - SY(__NR_gettimeofday, x0, x0+1); + SY(__NR_gettimeofday, x0, x0+1); FAIL; // __NR_settimeofday 79 GO(__NR_settimeofday, "2s 2m"); - SY(__NR_settimeofday, x0, x0+1); + SY(__NR_settimeofday, x0, x0+1); FAIL; // __NR_getgroups 80 GO(__NR_getgroups, "2s 1m"); - SY(__NR_getgroups, x0+1, x0+1); + SY(__NR_getgroups, x0+1, x0+1); FAIL; // __NR_setgroups 81 GO(__NR_setgroups, "2s 1m"); - SY(__NR_setgroups, x0+1, x0+1); + SY(__NR_setgroups, x0+1, x0+1); FAIL; // __NR_select 82 { long args[5] = { x0+8, x0+0xffffffee, x0+1, x0+1, x0+1 }; GO(__NR_select, "1s 4m"); - SY(__NR_select, args+x0); + SY(__NR_select, args+x0); FAIL; } // __NR_symlink 83 GO(__NR_symlink, "2s 2m"); - SY(__NR_symlink, x0, x0); + SY(__NR_symlink, x0, x0); FAIL; // __NR_oldlstat 84 GO(__NR_oldlstat, "n/a"); @@ -374,19 +377,19 @@ int main(void) // __NR_readlink 85 GO(__NR_readlink, "3s 2m"); - SY(__NR_readlink, x0+1, x0+1, x0+1); + SY(__NR_readlink, x0+1, x0+1, x0+1); FAIL; // __NR_uselib 86 GO(__NR_uselib, "n/a"); - //SY(__NR_uselib); // (Not yet handled by Valgrind) + //SY(__NR_uselib); // (Not yet handled by Valgrind) FAIL; // __NR_swapon 87 GO(__NR_swapon, "n/a"); - //SY(__NR_swapon); // (Not yet handled by Valgrind) + //SY(__NR_swapon); // (Not yet handled by Valgrind) FAIL; // __NR_reboot 88 GO(__NR_reboot, "n/a"); - //SY(__NR_reboot); // (Not yet handled by Valgrind) + //SY(__NR_reboot); // (Not yet handled by Valgrind) FAIL; // __NR_readdir 89 GO(__NR_readdir, "n/a"); @@ -396,81 +399,81 @@ int main(void) { long args[6] = { x0, x0, x0, x0, x0-1, x0 }; GO(__NR_mmap, "1s 0m"); - SY(__NR_mmap, args+x0); + SY(__NR_mmap, args+x0); FAIL; } // __NR_munmap 91 GO(__NR_munmap, "2s 0m"); - SY(__NR_munmap, x0, x0); + SY(__NR_munmap, x0, x0); FAIL; // __NR_truncate 92 GO(__NR_truncate, "2s 1m"); - SY(__NR_truncate, x0, x0); + SY(__NR_truncate, x0, x0); FAIL; // __NR_ftruncate 93 GO(__NR_ftruncate, "2s 0m"); - SY(__NR_ftruncate, x0, x0); + SY(__NR_ftruncate, x0, x0); FAIL; // __NR_fchmod 94 GO(__NR_fchmod, "2s 0m"); - SY(__NR_fchmod, x0-1, x0); + SY(__NR_fchmod, x0-1, x0); FAIL; // __NR_fchown 95 GO(__NR_fchown, "3s 0m"); - SY(__NR_fchown, x0, x0, x0); + SY(__NR_fchown, x0, x0, x0); FAIL; // __NR_getpriority 96 GO(__NR_getpriority, "2s 0m"); - SY(__NR_getpriority, x0, x0); + SY(__NR_getpriority, x0-1, x0); FAIL; // __NR_setpriority 97 GO(__NR_setpriority, "3s 0m"); - SY(__NR_setpriority, x0, x0, x0); + SY(__NR_setpriority, x0-1, x0, x0); FAIL; // __NR_profil 98 GO(__NR_profil, "ni"); - SY(__NR_profil); + SY(__NR_profil); FAIL; // __NR_statfs 99 GO(__NR_statfs, "2s 2m"); - SY(__NR_statfs, x0, x0); + SY(__NR_statfs, x0, x0); FAIL; // __NR_fstatfs 100 GO(__NR_fstatfs, "2s 1m"); - SY(__NR_fstatfs, x0, x0); + SY(__NR_fstatfs, x0, x0); FAIL; // __NR_ioperm 101 GO(__NR_ioperm, "3s 0m"); - SY(__NR_ioperm, x0, x0, x0); + SY(__NR_ioperm, x0, x0, x0); FAIL; // __NR_socketcall 102 // XXX: need to do properly // GO(__NR_socketcall, "2s 1m"); -// SY(__NR_socketcall, x0+SYS_SOCKETPAIR, x0); +// SY(__NR_socketcall, x0+SYS_SOCKETPAIR, x0); FAIL; // __NR_syslog 103 GO(__NR_syslog, "3s 1m"); - SY(__NR_syslog, x0+2, x0, x0+1); + SY(__NR_syslog, x0+2, x0, x0+1); FAIL; // __NR_setitimer 104 GO(__NR_setitimer, "3s 2m"); - SY(__NR_setitimer, x0, x0+1, x0+1); + SY(__NR_setitimer, x0, x0+1, x0+1); FAIL; // __NR_getitimer 105 GO(__NR_getitimer, "2s 1m"); - SY(__NR_getitimer, x0, x0, x0); + SY(__NR_getitimer, x0, x0, x0); FAIL; // __NR_stat 106 GO(__NR_stat, "2s 2m"); - SY(__NR_stat, x0, x0); + SY(__NR_stat, x0, x0); FAIL; // __NR_lstat 107 GO(__NR_lstat, "2s 2m"); - SY(__NR_lstat, x0, x0); + SY(__NR_lstat, x0, x0); FAIL; // __NR_fstat 108 GO(__NR_fstat, "2s 1m"); - SY(__NR_fstat, x0, x0); + SY(__NR_fstat, x0, x0); FAIL; // __NR_olduname 109 GO(__NR_olduname, "n/a"); @@ -478,15 +481,15 @@ int main(void) // __NR_iopl 110 GO(__NR_iopl, "1s 0m"); - SY(__NR_iopl, x0); + SY(__NR_iopl, x0+100); FAIL; // __NR_vhangup 111 GO(__NR_vhangup, "0s 0m"); - SY(__NR_vhangup); + SY(__NR_vhangup); SUCC_OR_FAIL; // Will succeed for superuser // __NR_idle 112 GO(__NR_idle, "ni"); - SY(__NR_idle); + SY(__NR_idle); FAIL; // __NR_vm86old 113 GO(__NR_vm86old, "n/a"); @@ -494,15 +497,15 @@ int main(void) // __NR_wait4 114 GO(__NR_wait4, "4s 2m"); - SY(__NR_wait4, x0, x0+1, x0, x0+1); + SY(__NR_wait4, x0, x0+1, x0, x0+1); FAIL; // __NR_swapoff 115 GO(__NR_swapoff, "n/a"); - //SY(__NR_swapoff); // (Not yet handled by Valgrind) + //SY(__NR_swapoff); // (Not yet handled by Valgrind) FAIL; // __NR_sysinfo 116 GO(__NR_sysinfo, "1s 1m"); - SY(__NR_sysinfo, x0); + SY(__NR_sysinfo, x0); FAIL; // __NR_ipc 117 // XXX: This is simplistic -- doesn't treat any of the sub-ops. @@ -510,15 +513,15 @@ int main(void) // use the 6th one! #include GO(__NR_ipc, "5s 0m"); - SY(__NR_ipc, x0+4, x0, x0, x0, x0, x0); + SY(__NR_ipc, x0+4, x0, x0, x0, x0, x0); FAIL; // __NR_fsync 118 GO(__NR_fsync, "1s 0m"); - SY(__NR_fsync, x0-1); + SY(__NR_fsync, x0-1); FAIL; // __NR_sigreturn 119 //GO(__NR_sigreturn, ".s .m"); - //SY(__NR_sigreturn); + //SY(__NR_sigreturn); FAIL; // __NR_clone 120 #include @@ -528,193 +531,191 @@ int main(void) #endif // XXX: should really be "4s 2m"? Not sure... (see PRE(sys_clone)) GO(__NR_clone, "4s 0m"); - if (SY(__NR_clone, x0|CLONE_PARENT_SETTID|SIGCHLD, x0, x0, x0) == 0) - { - SY(__NR_exit, 0); + SY(__NR_clone, x0|CLONE_PARENT_SETTID|SIGCHLD, x0, x0, x0); FAIL; + if (0 == res) { + SY(__NR_exit, 0); FAIL; } // __NR_setdomainname 121 GO(__NR_setdomainname, "n/a"); - //SY(__NR_setdomainname); // (Not yet handled by Valgrind) + //SY(__NR_setdomainname); // (Not yet handled by Valgrind) FAIL; // __NR_uname 122 GO(__NR_uname, "1s 1m"); - SY(__NR_uname, x0); + SY(__NR_uname, x0); FAIL; // __NR_modify_ldt 123 GO(__NR_modify_ldt, "3s 1m"); - SY(__NR_modify_ldt, x0, x0, x0+1); + SY(__NR_modify_ldt, x0+1, x0, x0+1); FAILx(EINVAL); // __NR_adjtimex 124 // XXX: need to do properly, but deref'ing NULL... // GO(__NR_adjtimex, "1s 1m"); -// SY(__NR_adjtimex, x0); +// SY(__NR_adjtimex, x0); FAIL; // __NR_mprotect 125 GO(__NR_mprotect, "3s 0m"); - SY(__NR_mprotect, x0, x0, x0); + SY(__NR_mprotect, x0+1, x0, x0); FAILx(EINVAL); // __NR_sigprocmask 126 - { - GO(__NR_sigprocmask, "3s 2m"); - SY(__NR_sigprocmask, x0, x0+&px[1], x0+&px[1]); - } + GO(__NR_sigprocmask, "3s 2m"); + SY(__NR_sigprocmask, x0, x0+&px[1], x0+&px[1]); SUCC; // __NR_create_module 127 GO(__NR_create_module, "ni"); - SY(__NR_create_module); + SY(__NR_create_module); FAIL; // __NR_init_module 128 GO(__NR_init_module, "3s 2m"); - SY(__NR_init_module, x0, x0+1, x0); + SY(__NR_init_module, x0, x0+1, x0); FAIL; // __NR_delete_module 129 GO(__NR_delete_module, "n/a"); - //SY(__NR_delete_module); // (Not yet handled by Valgrind) + //SY(__NR_delete_module); // (Not yet handled by Valgrind) FAIL; // __NR_get_kernel_syms 130 GO(__NR_get_kernel_syms, "ni"); - SY(__NR_get_kernel_syms); + SY(__NR_get_kernel_syms); FAIL; // __NR_quotactl 131 GO(__NR_quotactl, "4s 1m"); - SY(__NR_quotactl, x0, x0, x0, x0); + SY(__NR_quotactl, x0, x0, x0, x0); FAIL; // __NR_getpgid 132 GO(__NR_getpgid, "1s 0m"); - SY(__NR_getpgid, x0); + SY(__NR_getpgid, x0-1); FAIL; // __NR_fchdir 133 GO(__NR_fchdir, "1s 0m"); - SY(__NR_fchdir, x0-1); + SY(__NR_fchdir, x0-1); FAIL; // __NR_bdflush 134 GO(__NR_bdflush, "n/a"); - //SY(__NR_bdflush); // (Not yet handled by Valgrind) + //SY(__NR_bdflush); // (Not yet handled by Valgrind) FAIL; // __NR_sysfs 135 //GO(__NR_sysfs, ".s .m"); - //SY(__NR_sysfs); + //SY(__NR_sysfs); FAIL; // __NR_personality 136 GO(__NR_personality, "1s 0m"); - SY(__NR_personality, x0); + SY(__NR_personality, x0+0xffffffff); SUCC; // __NR_afs_syscall 137 GO(__NR_afs_syscall, "ni"); - SY(__NR_afs_syscall); + SY(__NR_afs_syscall); FAIL; // __NR_setfsuid 138 GO(__NR_setfsuid, "1s 0m"); - SY(__NR_setfsuid, x0); + SY(__NR_setfsuid, x0); SUCC; // This syscall has a stupid return value // __NR_setfsgid 139 GO(__NR_setfsgid, "1s 0m"); - SY(__NR_setfsgid, x0); + SY(__NR_setfsgid, x0); SUCC; // This syscall has a stupid return value // __NR__llseek 140 GO(__NR__llseek, "5s 1m"); - SY(__NR__llseek, x0, x0, x0, x0, x0); + SY(__NR__llseek, x0, x0, x0, x0, x0); FAIL; // __NR_getdents 141 GO(__NR_getdents, "3s 1m"); - SY(__NR_getdents, x0, x0, x0+1); + SY(__NR_getdents, x0, x0, x0+1); FAIL; // __NR__newselect 142 GO(__NR__newselect, "5s 4m"); - SY(__NR__newselect, x0+8, x0+0xffffffff, x0+1, x0+1, x0+1); + SY(__NR__newselect, x0+8, x0+0xffffffff, x0+1, x0+1, x0+1); FAIL; // __NR_flock 143 GO(__NR_flock, "2s 0m"); - SY(__NR_flock, x0, x0); + SY(__NR_flock, x0, x0); FAIL; // __NR_msync 144 - GO(__NR_msync, "3s 0m"); - SY(__NR_msync, x0, x0, x0); + GO(__NR_msync, "3s 1m"); + SY(__NR_msync, x0, x0+1, x0); FAIL; // __NR_readv 145 GO(__NR_readv, "3s 1m"); - SY(__NR_readv, x0, x0, x0+1); + SY(__NR_readv, x0, x0, x0+1); FAIL; // __NR_writev 146 GO(__NR_writev, "3s 1m"); - SY(__NR_writev, x0, x0, x0+1); + SY(__NR_writev, x0, x0, x0+1); FAIL; // __NR_getsid 147 GO(__NR_getsid, "1s 0m"); - SY(__NR_getsid, x0); + SY(__NR_getsid, x0-1); FAIL; // __NR_fdatasync 148 GO(__NR_fdatasync, "1s 0m"); - SY(__NR_fdatasync, x0-1); + SY(__NR_fdatasync, x0-1); FAIL; // __NR__sysctl 149 GO(__NR__sysctl, "1s 1m"); - SY(__NR__sysctl, x0); + SY(__NR__sysctl, x0); FAIL; // __NR_mlock 150 GO(__NR_mlock, "2s 0m"); - SY(__NR_mlock, x0, x0); + SY(__NR_mlock, x0, x0+1); FAIL; // __NR_munlock 151 GO(__NR_munlock, "2s 0m"); - SY(__NR_munlock, x0, x0); + SY(__NR_munlock, x0, x0+1); FAIL; // __NR_mlockall 152 - GO(__NR_mlockall, "2s 0m"); - SY(__NR_mlockall, x0, x0); + GO(__NR_mlockall, "1s 0m"); + SY(__NR_mlockall, x0-1); FAIL; // __NR_munlockall 153 GO(__NR_munlockall, "0s 0m"); - SY(__NR_munlockall); + SY(__NR_munlockall); SUCC; // __NR_sched_setparam 154 GO(__NR_sched_setparam, "2s 1m"); - SY(__NR_sched_setparam, x0, x0); + SY(__NR_sched_setparam, x0, x0); FAIL; // __NR_sched_getparam 155 GO(__NR_sched_getparam, "2s 1m"); - SY(__NR_sched_getparam, x0, x0); + SY(__NR_sched_getparam, x0, x0); FAIL; // __NR_sched_setscheduler 156 GO(__NR_sched_setscheduler, "3s 1m"); - SY(__NR_sched_setscheduler, x0, x0, x0+1); + SY(__NR_sched_setscheduler, x0-1, x0, x0+1); FAIL; // __NR_sched_getscheduler 157 GO(__NR_sched_getscheduler, "1s 0m"); - SY(__NR_sched_getscheduler, x0); + SY(__NR_sched_getscheduler, x0-1); FAIL; // __NR_sched_yield 158 //GO(__NR_sched_yield, ".s .m"); - //SY(__NR_sched_yield); + //SY(__NR_sched_yield); FAIL; // __NR_sched_get_priority_max 159 GO(__NR_sched_get_priority_max, "1s 0m"); - SY(__NR_sched_get_priority_max, x0); + SY(__NR_sched_get_priority_max, x0-1); FAIL; // __NR_sched_get_priority_min 160 GO(__NR_sched_get_priority_min, "1s 0m"); - SY(__NR_sched_get_priority_min, x0); + SY(__NR_sched_get_priority_min, x0-1); FAIL; // __NR_sched_rr_get_interval 161 GO(__NR_sched_rr_get_interval, "n/a"); - //SY(__NR_sched_rr_get_interval); // (Not yet handled by Valgrind) + //SY(__NR_sched_rr_get_interval); // (Not yet handled by Valgrind) FAIL; // __NR_nanosleep 162 GO(__NR_nanosleep, "2s 2m"); - SY(__NR_nanosleep, x0, x0+1); + SY(__NR_nanosleep, x0, x0+1); FAIL; // __NR_mremap 163 //GO(__NR_mremap, ".s .m"); - //SY(__NR_mremap); + //SY(__NR_mremap); FAIL; // __NR_setresuid 164 GO(__NR_setresuid, "3s 0m"); - SY(__NR_setresuid, x0, x0, x0); + SY(__NR_setresuid, x0, x0, x0); FAIL; // __NR_getresuid 165 GO(__NR_getresuid, "3s 3m"); - SY(__NR_getresuid, x0, x0, x0); + SY(__NR_getresuid, x0, x0, x0); FAIL; // __NR_vm86 166 GO(__NR_vm86, "n/a"); @@ -722,295 +723,295 @@ int main(void) // __NR_query_module 167 GO(__NR_query_module, "ni"); - SY(__NR_query_module); + SY(__NR_query_module); FAIL; // __NR_poll 168 GO(__NR_poll, "3s 1m"); - SY(__NR_poll, x0, x0+1, x0); + SY(__NR_poll, x0, x0+1, x0); FAIL; // __NR_nfsservctl 169 GO(__NR_nfsservctl, "n/a"); - //SY(__NR_nfsservctl); // (Not yet handled by Valgrind) + //SY(__NR_nfsservctl); // (Not yet handled by Valgrind) FAIL; // __NR_setresgid 170 GO(__NR_setresgid, "3s 0m"); - SY(__NR_setresgid, x0, x0, x0); + SY(__NR_setresgid, x0, x0, x0); FAIL; // __NR_getresgid 171 GO(__NR_getresgid, "3s 3m"); - SY(__NR_getresgid, x0, x0, x0); + SY(__NR_getresgid, x0, x0, x0); FAIL; // __NR_prctl 172 GO(__NR_prctl, "5s 0m"); - SY(__NR_prctl, x0, x0, x0, x0, x0); + SY(__NR_prctl, x0, x0, x0, x0, x0); FAIL; // __NR_rt_sigreturn 173 GO(__NR_rt_sigreturn, "n/a"); - //SY(__NR_rt_sigreturn); // (Not yet handled by Valgrind) + //SY(__NR_rt_sigreturn); // (Not yet handled by Valgrind) FAIL; // __NR_rt_sigaction 174 GO(__NR_rt_sigaction, "4s 2m"); - SY(__NR_rt_sigaction, x0, x0+1, x0+1, x0); + SY(__NR_rt_sigaction, x0, x0+1, x0+1, x0); FAIL; // __NR_rt_sigprocmask 175 GO(__NR_rt_sigprocmask, "4s 2m"); - SY(__NR_rt_sigprocmask, x0, x0+1, x0+1, x0); + SY(__NR_rt_sigprocmask, x0, x0+1, x0+1, x0); FAIL; // __NR_rt_sigpending 176 GO(__NR_rt_sigpending, "2s 1m"); - SY(__NR_rt_sigpending, x0, x0+1); + SY(__NR_rt_sigpending, x0, x0+1); FAIL; // __NR_rt_sigtimedwait 177 GO(__NR_rt_sigtimedwait, "4s 3m"); - SY(__NR_rt_sigtimedwait, x0+1, x0+1, x0+1, x0); + SY(__NR_rt_sigtimedwait, x0+1, x0+1, x0+1, x0); FAIL; // __NR_rt_sigqueueinfo 178 - //GO(__NR_rt_sigqueueinfo, ".s .m"); - //SY(__NR_rt_sigqueueinfo); + GO(__NR_rt_sigqueueinfo, "3s 1m"); + SY(__NR_rt_sigqueueinfo, x0, x0+1, x0); FAIL; // __NR_rt_sigsuspend 179 //GO(__NR_rt_sigsuspend, ".s .m"); - //SY(__NR_rt_sigsuspend); + //SY(__NR_rt_sigsuspend); FAIL; // __NR_pread64 180 GO(__NR_pread64, "5s 1m"); - SY(__NR_pread64, x0, x0, x0+1, x0, x0); + SY(__NR_pread64, x0, x0, x0+1, x0, x0); FAIL; // __NR_pwrite64 181 GO(__NR_pwrite64, "5s 1m"); - SY(__NR_pwrite64, x0, x0, x0+1, x0, x0); + SY(__NR_pwrite64, x0, x0, x0+1, x0, x0); FAIL; // __NR_chown 182 GO(__NR_chown, "3s 1m"); - SY(__NR_chown, x0, x0, x0); + SY(__NR_chown, x0, x0, x0); FAIL; // __NR_getcwd 183 GO(__NR_getcwd, "2s 1m"); - SY(__NR_getcwd, x0, x0+1); + SY(__NR_getcwd, x0, x0+1); FAIL; // __NR_capget 184 GO(__NR_capget, "2s 2m"); - SY(__NR_capget, x0, x0); + SY(__NR_capget, x0, x0); FAIL; // __NR_capset 185 GO(__NR_capset, "2s 2m"); - SY(__NR_capset, x0, x0); + SY(__NR_capset, x0, x0); FAIL; // __NR_sigaltstack 186 //GO(__NR_sigaltstack, ".s .m"); - //SY(__NR_sigaltstack); + //SY(__NR_sigaltstack); FAIL; // __NR_sendfile 187 GO(__NR_sendfile, "4s 1m"); - SY(__NR_sendfile, x0, x0, x0+1, x0); + SY(__NR_sendfile, x0, x0, x0+1, x0); FAIL; // __NR_getpmsg 188 //GO(__NR_getpmsg, ".s .m"); - //SY(__NR_getpmsg); + //SY(__NR_getpmsg); FAIL; // __NR_putpmsg 189 //GO(__NR_putpmsg, ".s .m"); - //SY(__NR_putpmsg); + //SY(__NR_putpmsg); FAIL; // __NR_vfork 190 - GO(__NR_vfork, "0s 0m"); + GO(__NR_vfork, "other"); // (sse scalar_vfork.c) // __NR_ugetrlimit 191 GO(__NR_ugetrlimit, "2s 1m"); - SY(__NR_ugetrlimit, x0, x0); + SY(__NR_ugetrlimit, x0, x0); FAIL; // __NR_mmap2 192 GO(__NR_mmap2, "5s 0m"); - SY(__NR_mmap2, x0, x0, x0, x0, x0-1, x0); + SY(__NR_mmap2, x0, x0, x0, x0, x0-1, x0); FAIL; // __NR_truncate64 193 GO(__NR_truncate64, "3s 1m"); - SY(__NR_truncate64, x0, x0, x0); + SY(__NR_truncate64, x0, x0, x0); FAIL; // __NR_ftruncate64 194 GO(__NR_ftruncate64, "3s 0m"); - SY(__NR_ftruncate64, x0, x0, x0); + SY(__NR_ftruncate64, x0, x0, x0); FAIL; // __NR_stat64 195 GO(__NR_stat64, "2s 2m"); - SY(__NR_stat64, x0, x0); + SY(__NR_stat64, x0, x0); FAIL; // __NR_lstat64 196 GO(__NR_lstat64, "2s 2m"); - SY(__NR_lstat64, x0, x0); + SY(__NR_lstat64, x0, x0); FAIL; // __NR_fstat64 197 GO(__NR_fstat64, "2s 1m"); - SY(__NR_fstat64, x0, x0); + SY(__NR_fstat64, x0, x0); FAIL; // __NR_lchown32 198 GO(__NR_lchown32, "3s 1m"); - SY(__NR_lchown32, x0, x0, x0); + SY(__NR_lchown32, x0, x0, x0); FAIL; // __NR_getuid32 199 GO(__NR_getuid32, "0s 0m"); - SY(__NR_getuid32); + SY(__NR_getuid32); SUCC; // __NR_getgid32 200 GO(__NR_getgid32, "0s 0m"); - SY(__NR_getgid32); + SY(__NR_getgid32); SUCC; // __NR_geteuid32 201 GO(__NR_geteuid32, "0s 0m"); - SY(__NR_geteuid32); + SY(__NR_geteuid32); SUCC; // __NR_getegid32 202 GO(__NR_getegid32, "0s 0m"); - SY(__NR_getegid32); + SY(__NR_getegid32); SUCC; // __NR_setreuid32 203 GO(__NR_setreuid32, "2s 0m"); - SY(__NR_setreuid32, x0, x0); + SY(__NR_setreuid32, x0, x0); FAIL; // __NR_setregid32 204 GO(__NR_setregid32, "2s 0m"); - SY(__NR_setregid32, x0, x0); + SY(__NR_setregid32, x0, x0); FAIL; // __NR_getgroups32 205 GO(__NR_getgroups32, "2s 1m"); - SY(__NR_getgroups32, x0+1, x0+1); + SY(__NR_getgroups32, x0+1, x0+1); FAIL; // __NR_setgroups32 206 GO(__NR_setgroups32, "2s 1m"); - SY(__NR_setgroups32, x0+1, x0+1); + SY(__NR_setgroups32, x0+1, x0+1); FAIL; // __NR_fchown32 207 GO(__NR_fchown32, "3s 0m"); - SY(__NR_fchown32, x0, x0, x0); + SY(__NR_fchown32, x0, x0, x0); FAIL; // __NR_setresuid32 208 GO(__NR_setresuid32, "3s 0m"); - SY(__NR_setresuid32, x0, x0, x0); + SY(__NR_setresuid32, x0, x0, x0); FAIL; // __NR_getresuid32 209 GO(__NR_getresuid32, "3s 3m"); - SY(__NR_getresuid32, x0, x0, x0); + SY(__NR_getresuid32, x0, x0, x0); FAIL; // __NR_setresgid32 210 GO(__NR_setresgid32, "3s 0m"); - SY(__NR_setresgid32, x0, x0, x0); + SY(__NR_setresgid32, x0, x0, x0); FAIL; // __NR_getresgid32 211 GO(__NR_getresgid32, "3s 3m"); - SY(__NR_getresgid32, x0, x0, x0); + SY(__NR_getresgid32, x0, x0, x0); FAIL; // __NR_chown32 212 GO(__NR_chown32, "3s 1m"); - SY(__NR_chown32, x0, x0, x0); + SY(__NR_chown32, x0, x0, x0); FAIL; // __NR_setuid32 213 GO(__NR_setuid32, "1s 0m"); - SY(__NR_setuid32, x0); + SY(__NR_setuid32, x0); FAIL; // __NR_setgid32 214 GO(__NR_setgid32, "1s 0m"); - SY(__NR_setgid32, x0); + SY(__NR_setgid32, x0); FAIL; // __NR_setfsuid32 215 GO(__NR_setfsuid32, "1s 0m"); - SY(__NR_setfsuid32, x0); + SY(__NR_setfsuid32, x0); SUCC; // This syscall has a stupid return value // __NR_setfsgid32 216 GO(__NR_setfsgid32, "1s 0m"); - SY(__NR_setfsgid32, x0); + SY(__NR_setfsgid32, x0); SUCC; // This syscall has a stupid return value // __NR_pivot_root 217 GO(__NR_pivot_root, "n/a"); - //SY(__NR_pivot_root); // (Not yet handled by Valgrind) + //SY(__NR_pivot_root); // (Not yet handled by Valgrind) FAIL; // __NR_mincore 218 GO(__NR_mincore, "3s 1m"); - SY(__NR_mincore, x0, x0+40960, x0); + SY(__NR_mincore, x0, x0+40960, x0); FAIL; // __NR_madvise 219 GO(__NR_madvise, "3s 0m"); - SY(__NR_madvise, x0, x0, x0); + SY(__NR_madvise, x0, x0+1, x0); FAILx(ENOMEM); // __NR_getdents64 220 GO(__NR_getdents64, "3s 1m"); - SY(__NR_getdents64, x0, x0, x0+1); + SY(__NR_getdents64, x0, x0, x0+1); FAIL; // __NR_fcntl64 221 GO(__NR_fcntl64, "3s 0m"); - SY(__NR_fcntl64, x0, x0, x0); + SY(__NR_fcntl64, x0-1, x0, x0); FAILx(EBADF); // 222 GO(222, "ni"); - SY(222); + SY(222); FAIL; // 223 GO(223, "ni"); - SY(223); + SY(223); FAIL; // __NR_gettid 224 GO(__NR_gettid, "n/a"); - //SY(__NR_gettid); // (Not yet handled by Valgrind) + //SY(__NR_gettid); // (Not yet handled by Valgrind) FAIL; // __NR_readahead 225 GO(__NR_readahead, "n/a"); - //SY(__NR_readahead); // (Not yet handled by Valgrind) + //SY(__NR_readahead); // (Not yet handled by Valgrind) FAIL; // __NR_setxattr 226 GO(__NR_setxattr, "5s 3m"); - SY(__NR_setxattr, x0, x0, x0, x0+1, x0); + SY(__NR_setxattr, x0, x0, x0, x0+1, x0); FAIL; // __NR_lsetxattr 227 GO(__NR_lsetxattr, "5s 3m"); - SY(__NR_lsetxattr, x0, x0, x0, x0+1, x0); + SY(__NR_lsetxattr, x0, x0, x0, x0+1, x0); FAIL; // __NR_fsetxattr 228 GO(__NR_fsetxattr, "5s 2m"); - SY(__NR_fsetxattr, x0, x0, x0, x0+1, x0); + SY(__NR_fsetxattr, x0, x0, x0, x0+1, x0); FAIL; // __NR_getxattr 229 GO(__NR_getxattr, "4s 3m"); - SY(__NR_getxattr, x0, x0, x0, x0+1); + SY(__NR_getxattr, x0, x0, x0, x0+1); FAIL; // __NR_lgetxattr 230 GO(__NR_lgetxattr, "4s 3m"); - SY(__NR_lgetxattr, x0, x0, x0, x0+1); + SY(__NR_lgetxattr, x0, x0, x0, x0+1); FAIL; // __NR_fgetxattr 231 GO(__NR_fgetxattr, "4s 2m"); - SY(__NR_fgetxattr, x0, x0, x0, x0+1); + SY(__NR_fgetxattr, x0, x0, x0, x0+1); FAIL; // __NR_listxattr 232 GO(__NR_listxattr, "3s 2m"); - SY(__NR_listxattr, x0, x0, x0+1); + SY(__NR_listxattr, x0, x0, x0+1); FAIL; // __NR_llistxattr 233 GO(__NR_llistxattr, "3s 2m"); - SY(__NR_llistxattr, x0, x0, x0+1); + SY(__NR_llistxattr, x0, x0, x0+1); FAIL; // __NR_flistxattr 234 GO(__NR_flistxattr, "3s 1m"); - SY(__NR_flistxattr, x0, x0, x0+1); + SY(__NR_flistxattr, x0-1, x0, x0+1); FAILx(EBADF); // __NR_removexattr 235 GO(__NR_removexattr, "2s 2m"); - SY(__NR_removexattr, x0, x0); + SY(__NR_removexattr, x0, x0); FAIL; // __NR_lremovexattr 236 GO(__NR_lremovexattr, "2s 2m"); - SY(__NR_lremovexattr, x0, x0); + SY(__NR_lremovexattr, x0, x0); FAIL; // __NR_fremovexattr 237 GO(__NR_fremovexattr, "2s 1m"); - SY(__NR_fremovexattr, x0, x0); + SY(__NR_fremovexattr, x0, x0); FAIL; // __NR_tkill 238 GO(__NR_tkill, "n/a"); - //SY(__NR_tkill); // (Not yet handled by Valgrind) + //SY(__NR_tkill); // (Not yet handled by Valgrind) FAIL; // __NR_sendfile64 239 GO(__NR_sendfile64, "4s 1m"); - SY(__NR_sendfile64, x0, x0, x0+1, x0); + SY(__NR_sendfile64, x0, x0, x0+1, x0); FAIL; // __NR_futex 240 #ifndef FUTEX_WAIT @@ -1018,27 +1019,27 @@ int main(void) #endif // XXX: again, glibc not doing 6th arg means we have only 5s errors GO(__NR_futex, "5s 2m"); - SY(__NR_futex, x0+FUTEX_WAIT, x0, x0, x0+1, x0, x0); + SY(__NR_futex, x0+FUTEX_WAIT, x0, x0, x0+1, x0, x0); FAIL; // __NR_sched_setaffinity 241 GO(__NR_sched_setaffinity, "3s 1m"); - SY(__NR_sched_setaffinity, x0, x0+1, x0); + SY(__NR_sched_setaffinity, x0, x0+1, x0); FAIL; // __NR_sched_getaffinity 242 GO(__NR_sched_getaffinity, "3s 1m"); - SY(__NR_sched_getaffinity, x0, x0+1, x0); + SY(__NR_sched_getaffinity, x0, x0+1, x0); FAIL; // __NR_set_thread_area 243 //GO(__NR_set_thread_area, ".s .m"); - //SY(__NR_set_thread_area); + //SY(__NR_set_thread_area); FAIL; // __NR_get_thread_area 244 //GO(__NR_get_thread_area, ".s .m"); - //SY(__NR_get_thread_area); + //SY(__NR_get_thread_area); FAIL; // __NR_io_setup 245 GO(__NR_io_setup, "2s 1m"); - SY(__NR_io_setup, x0, x0); + SY(__NR_io_setup, x0, x0); FAIL; // __NR_io_destroy 246 { @@ -1051,28 +1052,28 @@ int main(void) } ring = { 0, 0 }; struct fake_aio_ring* ringptr = ˚ GO(__NR_io_destroy, "1s 0m"); - SY(__NR_io_destroy, x0+&ringptr); + SY(__NR_io_destroy, x0+&ringptr); FAIL; } // __NR_io_getevents 247 GO(__NR_io_getevents, "5s 2m"); - SY(__NR_io_getevents, x0, x0, x0+1, x0, x0+1); + SY(__NR_io_getevents, x0, x0, x0+1, x0, x0+1); FAIL; // __NR_io_submit 248 GO(__NR_io_submit, "3s 1m"); - SY(__NR_io_submit, x0, x0+1, x0); + SY(__NR_io_submit, x0, x0+1, x0); FAIL; // __NR_io_cancel 249 GO(__NR_io_cancel, "3s 2m"); - SY(__NR_io_cancel, x0, x0, x0); + SY(__NR_io_cancel, x0, x0, x0); FAIL; // __NR_fadvise64 250 GO(__NR_fadvise64, "n/a"); - //SY(__NR_fadvise64); // (Not yet handled by Valgrind) + //SY(__NR_fadvise64); // (Not yet handled by Valgrind) FAIL; // 251 GO(251, "ni"); - SY(251); + SY(251); FAIL; // __NR_exit_group 252 GO(__NR_exit_group, "other"); @@ -1080,135 +1081,135 @@ int main(void) // __NR_lookup_dcookie 253 GO(__NR_lookup_dcookie, "4s 1m"); - SY(__NR_lookup_dcookie, x0, x0, x0, x0+1); + SY(__NR_lookup_dcookie, x0, x0, x0, x0+1); FAIL; // __NR_epoll_create 254 GO(__NR_epoll_create, "1s 0m"); - SY(__NR_epoll_create, x0); + SY(__NR_epoll_create, x0); FAIL; // __NR_epoll_ctl 255 GO(__NR_epoll_ctl, "4s 1m"); - SY(__NR_epoll_ctl, x0, x0, x0, x0); + SY(__NR_epoll_ctl, x0, x0, x0, x0); FAIL; // __NR_epoll_wait 256 GO(__NR_epoll_wait, "4s 1m"); - SY(__NR_epoll_wait, x0, x0, x0+1, x0); + SY(__NR_epoll_wait, x0, x0, x0+1, x0); FAIL; // __NR_remap_file_pages 257 GO(__NR_remap_file_pages, "n/a"); - //SY(__NR_remap_file_pages); // (Not yet handled by Valgrind) + //SY(__NR_remap_file_pages); // (Not yet handled by Valgrind) FAIL; // __NR_set_tid_address 258 GO(__NR_set_tid_address, "1s 0m"); - SY(__NR_set_tid_address, x0); + SY(__NR_set_tid_address, x0); SUCC; // __NR_timer_create 259 - //GO(__NR_timer_create, ".s .m"); - //SY(__NR_timer_create); + GO(__NR_timer_create, "3s 2m"); + SY(__NR_timer_create, x0, x0+1, x0); FAIL; // __NR_timer_settime (__NR_timer_create+1) - //GO(__NR_timer_settime, ".s .m"); - //SY(__NR_timer_settime); + GO(__NR_timer_settime, "4s 2m"); + SY(__NR_timer_settime, x0, x0, x0, x0+1); FAIL; // __NR_timer_gettime (__NR_timer_create+2) - //GO(__NR_timer_gettime, ".s .m"); - //SY(__NR_timer_gettime); + GO(__NR_timer_gettime, "2s 1m"); + SY(__NR_timer_gettime, x0, x0); FAIL; // __NR_timer_getoverrun (__NR_timer_create+3) - //GO(__NR_timer_getoverrun, ".s .m"); - //SY(__NR_timer_getoverrun); + GO(__NR_timer_getoverrun, "1s 0m"); + SY(__NR_timer_getoverrun, x0); FAIL; // __NR_timer_delete (__NR_timer_create+4) - //GO(__NR_timer_delete, ".s .m"); - //SY(__NR_timer_delete); + GO(__NR_timer_delete, "1s 0m"); + SY(__NR_timer_delete, x0); FAIL; // __NR_clock_settime (__NR_timer_create+5) - //GO(__NR_clock_settime, ".s .m"); - //SY(__NR_clock_settime); + GO(__NR_clock_settime, "2s 1m"); + SY(__NR_clock_settime, x0, x0); FAIL; FAIL; // __NR_clock_gettime (__NR_timer_create+6) - //GO(__NR_clock_gettime, ".s .m"); - //SY(__NR_clock_gettime); + GO(__NR_clock_gettime, "2s 1m"); + SY(__NR_clock_gettime, x0, x0); FAIL; // __NR_clock_getres (__NR_timer_create+7) - //GO(__NR_clock_getres, ".s .m"); - //SY(__NR_clock_getres); + GO(__NR_clock_getres, "2s 1m"); + SY(__NR_clock_getres, x0+1, x0+1); FAIL; FAIL; // __NR_clock_nanosleep (__NR_timer_create+8) - //GO(__NR_clock_nanosleep, ".s .m"); - //SY(__NR_clock_nanosleep); + GO(__NR_clock_nanosleep, "n/a"); + //SY(__NR_clock_nanosleep); // (Not yet handled by Valgrind) FAIL; // __NR_statfs64 268 GO(__NR_statfs64, "3s 2m"); - SY(__NR_statfs64, x0, x0+1, x0); + SY(__NR_statfs64, x0, x0+1, x0); FAIL; // __NR_fstatfs64 269 GO(__NR_fstatfs64, "3s 1m"); - SY(__NR_fstatfs64, x0, x0+1, x0); + SY(__NR_fstatfs64, x0, x0+1, x0); FAIL; // __NR_tgkill 270 GO(__NR_tgkill, "n/a"); - //SY(__NR_tgkill); // (Not yet handled by Valgrind) + //SY(__NR_tgkill); // (Not yet handled by Valgrind) FAIL; // __NR_utimes 271 GO(__NR_utimes, "2s 2m"); - SY(__NR_utimes, x0, x0+1); + SY(__NR_utimes, x0, x0+1); FAIL; // __NR_fadvise64_64 272 GO(__NR_fadvise64_64, "n/a"); - //SY(__NR_fadvise64_64); // (Not yet handled by Valgrind) + //SY(__NR_fadvise64_64); // (Not yet handled by Valgrind) FAIL; // __NR_vserver 273 GO(__NR_vserver, "ni"); - SY(__NR_vserver); + SY(__NR_vserver); FAIL; // __NR_mbind 274 GO(__NR_mbind, "n/a"); - //SY(__NR_mbind); // (Not yet handled by Valgrind) + //SY(__NR_mbind); // (Not yet handled by Valgrind) FAIL; // __NR_get_mempolicy 275 GO(__NR_get_mempolicy, "n/a"); - //SY(__NR_get_mempolicy); // (Not yet handled by Valgrind) + //SY(__NR_get_mempolicy); // (Not yet handled by Valgrind) FAIL; // __NR_set_mempolicy 276 GO(__NR_set_mempolicy, "n/a"); - //SY(__NR_set_mempolicy); // (Not yet handled by Valgrind) + //SY(__NR_set_mempolicy); // (Not yet handled by Valgrind) FAIL; // __NR_mq_open 277 GO(__NR_mq_open, "4s 2m"); - SY(__NR_mq_open, x0, x0+O_CREAT, x0, x0+1); + SY(__NR_mq_open, x0, x0+O_CREAT, x0, x0+1); FAIL; // __NR_mq_unlink (__NR_mq_open+1) GO(__NR_mq_unlink, "1s 1m"); - SY(__NR_mq_unlink, x0); + SY(__NR_mq_unlink, x0); FAIL; // __NR_mq_timedsend (__NR_mq_open+2) GO(__NR_mq_timedsend, "5s 2m"); - SY(__NR_mq_timedsend, x0, x0, x0+1, x0, x0+1); + SY(__NR_mq_timedsend, x0, x0, x0+1, x0, x0+1); FAIL; // __NR_mq_timedreceive (__NR_mq_open+3) GO(__NR_mq_timedreceive, "5s 3m"); - SY(__NR_mq_timedreceive, x0, x0, x0+1, x0+1, x0+1); + SY(__NR_mq_timedreceive, x0, x0, x0+1, x0+1, x0+1); FAIL; // __NR_mq_notify (__NR_mq_open+4) GO(__NR_mq_notify, "2s 1m"); - SY(__NR_mq_notify, x0, x0+1); + SY(__NR_mq_notify, x0, x0+1); FAIL; // __NR_mq_getsetattr (__NR_mq_open+5) GO(__NR_mq_getsetattr, "3s 2m"); - SY(__NR_mq_getsetattr, x0, x0+1, x0+1); + SY(__NR_mq_getsetattr, x0, x0+1, x0+1); FAIL; // __NR_sys_kexec_load 283 GO(__NR_sys_kexec_load, "ni"); - SY(__NR_sys_kexec_load); + SY(__NR_sys_kexec_load); FAIL; // no such syscall... GO(9999, "1e"); - SY(9999); + SY(9999); FAIL; // __NR_exit 1 GO(__NR_exit, "1s 0m"); - SY(__NR_exit, x0); + SY(__NR_exit, x0); FAIL; assert(0); } diff --git a/memcheck/tests/scalar.h b/memcheck/tests/scalar.h index 4b0e23a3d5..0cbb2fe36a 100644 --- a/memcheck/tests/scalar.h +++ b/memcheck/tests/scalar.h @@ -2,6 +2,7 @@ #include "../../coregrind/x86-linux/vki_unistd.h" #include +#include #include #include #include @@ -24,6 +25,25 @@ extern long int syscall (long int __sysno, ...) __THROW; "-----------------------------------------------------\n", \ __NR_xxx, #__NR_xxx, s); -#define SY syscall +#define SY res = syscall +#define FAIL assert(-1 == res); +#define SUCC assert(-1 != res); +#define SUCC_OR_FAIL /* no test */ + +#define FAILx(E) \ + do { \ + int myerrno = errno; \ + if (-1 == res) { \ + if (E == myerrno) { \ + /* as expected */ \ + } else { \ + fprintf(stderr, "Expected error %s (%d), got %d\n", #E, E, myerrno); \ + exit(1); \ + } \ + } else { \ + fprintf(stderr, "Expected error %s (%d), got success\n", #E, E); \ + exit(1); \ + } \ + } while (0); diff --git a/memcheck/tests/scalar.stderr.exp b/memcheck/tests/scalar.stderr.exp index e01ebe5c87..313da02f11 100644 --- a/memcheck/tests/scalar.stderr.exp +++ b/memcheck/tests/scalar.stderr.exp @@ -1875,7 +1875,7 @@ Syscall param flock(operation) contains uninitialised byte(s) by 0x........: __libc_start_main (...libc...) by 0x........: ... ----------------------------------------------------- -144: __NR_msync 3s 0m +144: __NR_msync 3s 1m ----------------------------------------------------- Syscall param msync(start) contains uninitialised byte(s) @@ -1892,6 +1892,12 @@ Syscall param msync(flags) contains uninitialised byte(s) at 0x........: syscall (in /...libc...) by 0x........: __libc_start_main (...libc...) by 0x........: ... + +Syscall param msync(start) points to unaddressable byte(s) + at 0x........: syscall (in /...libc...) + by 0x........: __libc_start_main (...libc...) + by 0x........: ... + Address 0x........ is not stack'd, malloc'd or (recently) free'd ----------------------------------------------------- 145: __NR_readv 3s 1m ----------------------------------------------------- @@ -1997,7 +2003,7 @@ Syscall param munlock(len) contains uninitialised byte(s) by 0x........: __libc_start_main (...libc...) by 0x........: ... ----------------------------------------------------- -152: __NR_mlockall 2s 0m +152: __NR_mlockall 1s 0m ----------------------------------------------------- Syscall param mlockall(flags) contains uninitialised byte(s) @@ -2424,6 +2430,30 @@ Syscall param rt_sigtimedwait(timeout) points to unaddressable byte(s) by 0x........: ... Address 0x........ is not stack'd, malloc'd or (recently) free'd ----------------------------------------------------- +178:__NR_rt_sigqueueinfo 3s 1m +----------------------------------------------------- + +Syscall param rt_sigqueueinfo(pid) contains uninitialised byte(s) + at 0x........: syscall (in /...libc...) + by 0x........: __libc_start_main (...libc...) + by 0x........: ... + +Syscall param rt_sigqueueinfo(sig) contains uninitialised byte(s) + at 0x........: syscall (in /...libc...) + by 0x........: __libc_start_main (...libc...) + by 0x........: ... + +Syscall param rt_sigqueueinfo(uinfo) contains uninitialised byte(s) + at 0x........: syscall (in /...libc...) + by 0x........: __libc_start_main (...libc...) + by 0x........: ... + +Syscall param rt_sigqueueinfo(uinfo) points to unaddressable byte(s) + at 0x........: syscall (in /...libc...) + by 0x........: __libc_start_main (...libc...) + by 0x........: ... + Address 0x........ is not stack'd, malloc'd or (recently) free'd +----------------------------------------------------- 180: __NR_pread64 5s 1m ----------------------------------------------------- @@ -2614,7 +2644,7 @@ Syscall param sendfile(offset) points to unaddressable byte(s) by 0x........: ... Address 0x........ is not stack'd, malloc'd or (recently) free'd ----------------------------------------------------- -190: __NR_vfork 0s 0m +190: __NR_vfork other ----------------------------------------------------- ----------------------------------------------------- 191: __NR_ugetrlimit 2s 1m @@ -3914,6 +3944,166 @@ Syscall param set_tid_address(tidptr) contains uninitialised byte(s) by 0x........: __libc_start_main (...libc...) by 0x........: ... ----------------------------------------------------- +259: __NR_timer_create 3s 2m +----------------------------------------------------- + +Syscall param timer_create(clockid) contains uninitialised byte(s) + at 0x........: syscall (in /...libc...) + by 0x........: __libc_start_main (...libc...) + by 0x........: ... + +Syscall param timer_create(evp) contains uninitialised byte(s) + at 0x........: syscall (in /...libc...) + by 0x........: __libc_start_main (...libc...) + by 0x........: ... + +Syscall param timer_create(timerid) contains uninitialised byte(s) + at 0x........: syscall (in /...libc...) + by 0x........: __libc_start_main (...libc...) + by 0x........: ... + +Syscall param timer_create(evp) points to unaddressable byte(s) + at 0x........: syscall (in /...libc...) + by 0x........: __libc_start_main (...libc...) + by 0x........: ... + Address 0x........ is not stack'd, malloc'd or (recently) free'd + +Syscall param timer_create(timerid) points to unaddressable byte(s) + at 0x........: syscall (in /...libc...) + by 0x........: __libc_start_main (...libc...) + by 0x........: ... + Address 0x........ is not stack'd, malloc'd or (recently) free'd +----------------------------------------------------- +260: __NR_timer_settime 4s 2m +----------------------------------------------------- + +Syscall param timer_settime(timerid) contains uninitialised byte(s) + at 0x........: syscall (in /...libc...) + by 0x........: __libc_start_main (...libc...) + by 0x........: ... + +Syscall param timer_settime(flags) contains uninitialised byte(s) + at 0x........: syscall (in /...libc...) + by 0x........: __libc_start_main (...libc...) + by 0x........: ... + +Syscall param timer_settime(value) contains uninitialised byte(s) + at 0x........: syscall (in /...libc...) + by 0x........: __libc_start_main (...libc...) + by 0x........: ... + +Syscall param timer_settime(ovalue) contains uninitialised byte(s) + at 0x........: syscall (in /...libc...) + by 0x........: __libc_start_main (...libc...) + by 0x........: ... + +Syscall param timer_settime(value) points to unaddressable byte(s) + at 0x........: syscall (in /...libc...) + by 0x........: __libc_start_main (...libc...) + by 0x........: ... + Address 0x........ is not stack'd, malloc'd or (recently) free'd + +Syscall param timer_settime(ovalue) points to unaddressable byte(s) + at 0x........: syscall (in /...libc...) + by 0x........: __libc_start_main (...libc...) + by 0x........: ... + Address 0x........ is not stack'd, malloc'd or (recently) free'd +----------------------------------------------------- +261: __NR_timer_gettime 2s 1m +----------------------------------------------------- + +Syscall param timer_gettime(timerid) contains uninitialised byte(s) + at 0x........: syscall (in /...libc...) + by 0x........: __libc_start_main (...libc...) + by 0x........: ... + +Syscall param timer_gettime(value) contains uninitialised byte(s) + at 0x........: syscall (in /...libc...) + by 0x........: __libc_start_main (...libc...) + by 0x........: ... + +Syscall param timer_gettime(value) points to unaddressable byte(s) + at 0x........: syscall (in /...libc...) + by 0x........: __libc_start_main (...libc...) + by 0x........: ... + Address 0x........ is not stack'd, malloc'd or (recently) free'd +----------------------------------------------------- +262:__NR_timer_getoverrun 1s 0m +----------------------------------------------------- + +Syscall param timer_getoverrun(timerid) contains uninitialised byte(s) + at 0x........: syscall (in /...libc...) + by 0x........: __libc_start_main (...libc...) + by 0x........: ... +----------------------------------------------------- +263: __NR_timer_delete 1s 0m +----------------------------------------------------- + +Syscall param timer_delete(timerid) contains uninitialised byte(s) + at 0x........: syscall (in /...libc...) + by 0x........: __libc_start_main (...libc...) + by 0x........: ... +----------------------------------------------------- +264: __NR_clock_settime 2s 1m +----------------------------------------------------- + +Syscall param clock_settime(clk_id) contains uninitialised byte(s) + at 0x........: syscall (in /...libc...) + by 0x........: __libc_start_main (...libc...) + by 0x........: ... + +Syscall param clock_settime(tp) contains uninitialised byte(s) + at 0x........: syscall (in /...libc...) + by 0x........: __libc_start_main (...libc...) + by 0x........: ... + +Syscall param clock_settime(tp) points to unaddressable byte(s) + at 0x........: syscall (in /...libc...) + by 0x........: __libc_start_main (...libc...) + by 0x........: ... + Address 0x........ is not stack'd, malloc'd or (recently) free'd +----------------------------------------------------- +265: __NR_clock_gettime 2s 1m +----------------------------------------------------- + +Syscall param clock_gettime(clk_id) contains uninitialised byte(s) + at 0x........: syscall (in /...libc...) + by 0x........: __libc_start_main (...libc...) + by 0x........: ... + +Syscall param clock_gettime(tp) contains uninitialised byte(s) + at 0x........: syscall (in /...libc...) + by 0x........: __libc_start_main (...libc...) + by 0x........: ... + +Syscall param clock_gettime(tp) points to unaddressable byte(s) + at 0x........: syscall (in /...libc...) + by 0x........: __libc_start_main (...libc...) + by 0x........: ... + Address 0x........ is not stack'd, malloc'd or (recently) free'd +----------------------------------------------------- +266: __NR_clock_getres 2s 1m +----------------------------------------------------- + +Syscall param clock_getres(clk_id) contains uninitialised byte(s) + at 0x........: syscall (in /...libc...) + by 0x........: __libc_start_main (...libc...) + by 0x........: ... + +Syscall param clock_getres(cres) contains uninitialised byte(s) + at 0x........: syscall (in /...libc...) + by 0x........: __libc_start_main (...libc...) + by 0x........: ... + +Syscall param clock_getres(cres) points to unaddressable byte(s) + at 0x........: syscall (in /...libc...) + by 0x........: __libc_start_main (...libc...) + by 0x........: ... + Address 0x........ is not stack'd, malloc'd or (recently) free'd +----------------------------------------------------- +267:__NR_clock_nanosleep n/a +----------------------------------------------------- +----------------------------------------------------- 268: __NR_statfs64 3s 2m ----------------------------------------------------- diff --git a/memcheck/tests/scalar_exit_group.c b/memcheck/tests/scalar_exit_group.c index 2e652d81bf..214d6c3df4 100644 --- a/memcheck/tests/scalar_exit_group.c +++ b/memcheck/tests/scalar_exit_group.c @@ -5,6 +5,7 @@ int main(void) // uninitialised, but we know px[0] is 0x0 long* px = malloc(sizeof(long)); long x0 = px[0]; + int res; // All __NR_xxx numbers are taken from x86 diff --git a/memcheck/tests/scalar_fork.c b/memcheck/tests/scalar_fork.c index 4cbf7629fb..805ade844c 100644 --- a/memcheck/tests/scalar_fork.c +++ b/memcheck/tests/scalar_fork.c @@ -2,6 +2,8 @@ int main(void) { + int res; + // All __NR_xxx numbers are taken from x86 // __NR_fork 2 --> arch/sys_fork() diff --git a/memcheck/tests/scalar_vfork.c b/memcheck/tests/scalar_vfork.c index 2158e58b2b..fe999fb923 100644 --- a/memcheck/tests/scalar_vfork.c +++ b/memcheck/tests/scalar_vfork.c @@ -2,6 +2,8 @@ int main(void) { + int res; + // All __NR_xxx numbers are taken from x86 // __NR_vfork 190 --> arch/sys_fork() [we can't use sys_vfork()]