struct pool *
allocate_pool()
{
struct pool *p = malloc(sizeof(struct pool));
assert(p);
p->allocated = 4096;
p->used = 0;
p->buf = malloc(p->allocated);
assert(p->buf);
memset(p->buf, 0, p->allocated);
VALGRIND_CREATE_MEMPOOL(p, 0, 0);
VALGRIND_MAKE_NOACCESS(p->buf, p->allocated);
return p;
}
/* Resize a block of memory, possibly re-allocating it. */
void *
ggc_realloc_stat (void *x, size_t size MEM_STAT_DECL)
{
void *r;
size_t old_size;
if (x == NULL)
return ggc_alloc_stat (size PASS_MEM_STAT);
old_size = ggc_get_size (x);
if (size <= old_size)
{
/* Mark the unwanted memory as unaccessible. We also need to make
the "new" size accessible, since ggc_get_size returns the size of
the pool, not the size of the individually allocated object, the
size which was previously made accessible. Unfortunately, we
don't know that previously allocated size. Without that
knowledge we have to lose some initialization-tracking for the
old parts of the object. An alternative is to mark the whole
old_size as reachable, but that would lose tracking of writes
after the end of the object (by small offsets). Discard the
handle to avoid handle leak. */
VALGRIND_DISCARD (VALGRIND_MAKE_NOACCESS ((char *) x + size,
old_size - size));
VALGRIND_DISCARD (VALGRIND_MAKE_READABLE (x, size));
return x;
}
r = ggc_alloc_stat (size PASS_MEM_STAT);
/* Since ggc_get_size returns the size of the pool, not the size of the
individually allocated object, we'd access parts of the old object
that were marked invalid with the memcpy below. We lose a bit of the
initialization-tracking since some of it may be uninitialized. */
VALGRIND_DISCARD (VALGRIND_MAKE_READABLE (x, old_size));
memcpy (r, x, old_size);
/* The old object is not supposed to be used anymore. */
ggc_free (x);
return r;
}
void allocate_chunk_at(void) {
extern LUSHAPI alloc_root_t at_alloc;
assert(at_alloc.freelist==NULL);
chunk_header_t *chkhd = malloc(sizeof(chunk_header_t) + SIZEOF_CHUNK_AT);
if (chkhd) {
chkhd->begin = (empty_alloc_t *) ((char*)chkhd + sizeof(chunk_header_t));
chkhd->end = (empty_alloc_t *) ((char*)chkhd->begin + SIZEOF_CHUNK_AT);
chkhd->next = at_alloc.chunklist;
at_alloc.chunklist = chkhd;
VALGRIND_MAKE_NOACCESS(chkhd->begin, SIZEOF_CHUNK_AT);
char *p = (char*)chkhd->begin + REDZONE_SIZE;
for (int i = 0; i < CONSCHUNKSIZE; i++, p+=SIZEOF_CELL) {
VALGRIND_MAKE_WRITABLE(p, sizeof(at));
empty_alloc_t *ea = (empty_alloc_t *)p;
ea->next = at_alloc.freelist;
ea->used = 0;
at_alloc.freelist = ea;
}
} else
RAISEF("not enough memory", NIL);
}
void allocate_chunk(alloc_root_t *ar) {
assert(ar->freelist==NULL);
size_t sizeof_cell = ar->sizeof_elem + 2*REDZONE_SIZE;
size_t sizeof_chunk = sizeof_cell*ar->chunksize;
chunk_header_t *chkhd = malloc(sizeof(chunk_header_t) + sizeof_chunk);
//printf("adding new chunk of size %d\n", ar->chunksize);
if (chkhd) {
chkhd->begin = (empty_alloc_t *) ((char*)chkhd + sizeof(chunk_header_t));
chkhd->end = (empty_alloc_t *) ((char*)chkhd->begin + sizeof_chunk);
chkhd->next = ar->chunklist;
ar->chunklist = chkhd;
char *p = (char*)chkhd->begin + REDZONE_SIZE;
for (int i = 0; i < ar->chunksize; i++, p+=sizeof_cell) {
empty_alloc_t *ea = (empty_alloc_t *)p;
ea->next = ar->freelist;
ea->used = 0;
ar->freelist = ea;
}
VALGRIND_MAKE_NOACCESS(chkhd->begin, sizeof_chunk);
} else
RAISEF("not enough memory", NIL);
}
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
// __NR_restart_syscall 0 // XXX: not yet handled, perhaps should be...
GO(__NR_restart_syscall, "n/a");
//SY(__NR_restart_syscall); // (Not yet handled by Valgrind) FAIL;
// __NR_exit 1
GO(__NR_exit, "below");
// (see below)
// __NR_fork 2
GO(__NR_fork, "other");
// (sse scalar_fork.c)
// __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); FAILx(EFAULT);
// __NR_write 4
GO(__NR_write, "3s 1m");
SY(__NR_write, x0, x0, x0+1); FAIL;
// __NR_open 5
GO(__NR_open, "(2-args) 2s 1m");
SY(__NR_open, x0, x0); FAIL;
// 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); FAIL;
// __NR_waitpid 7
GO(__NR_waitpid, "3s 1m");
SY(__NR_waitpid, x0, x0+1, x0); FAIL;
// __NR_creat 8
GO(__NR_creat, "2s 1m");
SY(__NR_creat, x0, x0); FAIL;
// __NR_link 9
GO(__NR_link, "2s 2m");
SY(__NR_link, x0, x0); FAIL;
// __NR_unlink 10
GO(__NR_unlink, "1s 1m");
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); FAIL;
// __NR_chdir 12
GO(__NR_chdir, "1s 1m");
SY(__NR_chdir, x0); FAIL;
// __NR_time 13
GO(__NR_time, "1s 1m");
SY(__NR_time, x0+1); FAIL;
// __NR_mknod 14
GO(__NR_mknod, "3s 1m");
SY(__NR_mknod, x0, x0, x0); FAIL;
// __NR_chmod 15
GO(__NR_chmod, "2s 1m");
SY(__NR_chmod, x0, x0); FAIL;
// __NR_lchown 16
GO(__NR_lchown, "n/a");
//SY(__NR_lchown); // (Not yet handled by Valgrind) FAIL;
// __NR_break 17
GO(__NR_break, "ni");
SY(__NR_break); FAIL;
// __NR_oldstat 18
GO(__NR_oldstat, "n/a");
// (obsolete, not handled by Valgrind)
// __NR_lseek 19
GO(__NR_lseek, "3s 0m");
SY(__NR_lseek, x0-1, x0, x0); FAILx(EBADF);
// __NR_getpid 20
GO(__NR_getpid, "0s 0m");
SY(__NR_getpid); SUCC;
// __NR_mount 21
GO(__NR_mount, "5s 3m");
SY(__NR_mount, x0, x0, x0, x0, x0); FAIL;
// __NR_umount 22
GO(__NR_umount, "1s 1m");
SY(__NR_umount, x0); FAIL;
// __NR_setuid 23
GO(__NR_setuid, "1s 0m");
SY(__NR_setuid, x0); FAIL;
// __NR_getuid 24
GO(__NR_getuid, "0s 0m");
SY(__NR_getuid); SUCC;
// __NR_stime 25
GO(__NR_stime, "n/a");
//SY(__NR_stime); // (Not yet handled by Valgrind) FAIL;
// __NR_ptrace 26
// XXX: memory pointed to be arg3 goes unchecked... otherwise would be 2m
GO(__NR_ptrace, "4s 1m");
SY(__NR_ptrace, x0+PTRACE_GETREGS, x0, x0, x0); FAIL;
// __NR_alarm 27
GO(__NR_alarm, "1s 0m");
SY(__NR_alarm, x0); SUCC;
// __NR_oldfstat 28
GO(__NR_oldfstat, "n/a");
// (obsolete, not handled by Valgrind)
// __NR_pause 29
GO(__NR_pause, "ignore");
// (hard to test, and no args so not much to be gained -- don't bother)
// __NR_utime 30
GO(__NR_utime, "2s 2m");
SY(__NR_utime, x0, x0+1); FAIL;
// __NR_stty 31
GO(__NR_stty, "ni");
SY(__NR_stty); FAIL;
// __NR_gtty 32
GO(__NR_gtty, "ni");
SY(__NR_gtty); FAIL;
// __NR_access 33
GO(__NR_access, "2s 1m");
SY(__NR_access, x0, x0); FAIL;
// __NR_nice 34
GO(__NR_nice, "1s 0m");
SY(__NR_nice, x0); SUCC;
// __NR_ftime 35
GO(__NR_ftime, "ni");
SY(__NR_ftime); FAIL;
// __NR_sync 36
GO(__NR_sync, "0s 0m");
SY(__NR_sync); SUCC;
// __NR_kill 37
GO(__NR_kill, "2s 0m");
SY(__NR_kill, x0, x0); SUCC;
// __NR_rename 38
GO(__NR_rename, "2s 2m");
SY(__NR_rename, x0, x0); FAIL;
// __NR_mkdir 39
GO(__NR_mkdir, "2s 1m");
SY(__NR_mkdir, x0, x0); FAIL;
// __NR_rmdir 40
GO(__NR_rmdir, "1s 1m");
SY(__NR_rmdir, x0); FAIL;
// __NR_dup 41
GO(__NR_dup, "1s 0m");
SY(__NR_dup, x0-1); FAIL;
// __NR_pipe 42
GO(__NR_pipe, "1s 1m");
SY(__NR_pipe, x0); FAIL;
// __NR_times 43
GO(__NR_times, "1s 1m");
SY(__NR_times, x0+1); FAIL;
// __NR_prof 44
GO(__NR_prof, "ni");
SY(__NR_prof); FAIL;
// __NR_brk 45
GO(__NR_brk, "1s 0m");
SY(__NR_brk, x0); SUCC;
// __NR_setgid 46
GO(__NR_setgid, "1s 0m");
SY(__NR_setgid, x0); FAIL;
// __NR_getgid 47
GO(__NR_getgid, "0s 0m");
SY(__NR_getgid); SUCC;
// __NR_signal 48
GO(__NR_signal, "n/a");
//SY(__NR_signal); // (Not yet handled by Valgrind) FAIL;
// __NR_geteuid 49
GO(__NR_geteuid, "0s 0m");
SY(__NR_geteuid); SUCC;
// __NR_getegid 50
GO(__NR_getegid, "0s 0m");
SY(__NR_getegid); SUCC;
// __NR_acct 51
GO(__NR_acct, "1s 1m");
SY(__NR_acct, x0); FAIL;
// __NR_umount2 52
GO(__NR_umount2, "2s 1m");
SY(__NR_umount2, x0, x0); FAIL;
// __NR_lock 53
GO(__NR_lock, "ni");
SY(__NR_lock); FAIL;
// __NR_ioctl 54
#include <asm/ioctls.h>
GO(__NR_ioctl, "3s 1m");
SY(__NR_ioctl, x0, x0+TCSETS, x0); FAIL;
// __NR_fcntl 55
// As with sys_open(), the 'fd' error is suppressed for the later ones.
// For F_GETFD the 3rd arg is ignored
GO(__NR_fcntl, "(GETFD) 2s 0m");
SY(__NR_fcntl, x0-1, x0+F_GETFD, x0); FAILx(EBADF);
// For F_DUPFD the 3rd arg is 'arg'
GO(__NR_fcntl, "(DUPFD) 1s 0m");
SY(__NR_fcntl, x0-1, x0+F_DUPFD, x0); FAILx(EBADF);
// For F_GETLK the 3rd arg is 'lock'
// on x86, this fails with EBADF. But on amd64 in 32-bit mode
// it fails with EFAULT.
GO(__NR_fcntl, "(GETLK) 1s 0m");
SY(__NR_fcntl, x0-1, x0+F_GETLK, x0); FAIL; //FAILx(EBADF);
// __NR_mpx 56
GO(__NR_mpx, "ni");
SY(__NR_mpx); FAIL;
// __NR_setpgid 57
GO(__NR_setpgid, "2s 0m");
SY(__NR_setpgid, x0, x0-1); FAIL;
// __NR_ulimit 58
GO(__NR_ulimit, "ni");
SY(__NR_ulimit); FAIL;
// __NR_oldolduname 59
GO(__NR_oldolduname, "n/a");
// (obsolete, not handled by Valgrind)
// __NR_umask 60
GO(__NR_umask, "1s 0m");
SY(__NR_umask, x0+022); SUCC;
// __NR_chroot 61
GO(__NR_chroot, "1s 1m");
SY(__NR_chroot, x0); FAIL;
// __NR_ustat 62
GO(__NR_ustat, "n/a");
// (deprecated, not handled by Valgrind)
// __NR_dup2 63
GO(__NR_dup2, "2s 0m");
SY(__NR_dup2, x0-1, x0); FAIL;
// __NR_getppid 64
GO(__NR_getppid, "0s 0m");
SY(__NR_getppid); SUCC;
// __NR_getpgrp 65
GO(__NR_getpgrp, "0s 0m");
SY(__NR_getpgrp); SUCC;
// __NR_setsid 66
GO(__NR_setsid, "0s 0m");
SY(__NR_setsid); SUCC_OR_FAIL;
// __NR_sigaction 67
GO(__NR_sigaction, "3s 4m");
SY(__NR_sigaction, x0, x0+&px[1], x0+&px[1]); FAIL;
// __NR_sgetmask 68 sys_sgetmask()
GO(__NR_sgetmask, "n/a");
//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) FAIL;
// __NR_setreuid 70
GO(__NR_setreuid, "2s 0m");
SY(__NR_setreuid, x0, x0); FAIL;
// __NR_setregid 71
GO(__NR_setregid, "2s 0m");
SY(__NR_setregid, x0, x0); FAIL;
// __NR_sigsuspend 72
// XXX: how do you use this function?
GO(__NR_sigsuspend, "ignore");
// (I don't know how to test this...)
// __NR_sigpending 73
GO(__NR_sigpending, "1s 1m");
SY(__NR_sigpending, x0); FAIL;
// __NR_sethostname 74
GO(__NR_sethostname, "n/a");
//SY(__NR_sethostname); // (Not yet handled by Valgrind) FAIL;
// __NR_setrlimit 75
GO(__NR_setrlimit, "2s 1m");
SY(__NR_setrlimit, x0, x0); FAIL;
// __NR_getrlimit 76
GO(__NR_getrlimit, "2s 1m");
SY(__NR_getrlimit, x0, x0); FAIL;
// __NR_getrusage 77
GO(__NR_getrusage, "2s 1m");
SY(__NR_getrusage, x0, x0); FAIL;
// __NR_gettimeofday 78
GO(__NR_gettimeofday, "2s 2m");
SY(__NR_gettimeofday, x0, x0+1); FAIL;
// __NR_settimeofday 79
GO(__NR_settimeofday, "2s 2m");
SY(__NR_settimeofday, x0, x0+1); FAIL;
// __NR_getgroups 80
GO(__NR_getgroups, "2s 1m");
SY(__NR_getgroups, x0+1, x0+1); FAIL;
// __NR_setgroups 81
GO(__NR_setgroups, "2s 1m");
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); FAIL;
}
// __NR_symlink 83
GO(__NR_symlink, "2s 2m");
SY(__NR_symlink, x0, x0); FAIL;
// __NR_oldlstat 84
GO(__NR_oldlstat, "n/a");
// (obsolete, not handled by Valgrind)
// __NR_readlink 85
GO(__NR_readlink, "3s 2m");
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) FAIL;
// __NR_swapon 87
GO(__NR_swapon, "n/a");
//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) FAIL;
// __NR_readdir 89
GO(__NR_readdir, "n/a");
// (superseded, not handled by Valgrind)
// __NR_mmap 90
{
long args[6] = { x0, x0, x0, x0, x0-1, x0 };
GO(__NR_mmap, "1s 0m");
SY(__NR_mmap, args+x0); FAIL;
}
// __NR_munmap 91
GO(__NR_munmap, "2s 0m");
SY(__NR_munmap, x0, x0); FAIL;
// __NR_truncate 92
GO(__NR_truncate, "2s 1m");
SY(__NR_truncate, x0, x0); FAIL;
// __NR_ftruncate 93
GO(__NR_ftruncate, "2s 0m");
SY(__NR_ftruncate, x0, x0); FAIL;
// __NR_fchmod 94
GO(__NR_fchmod, "2s 0m");
SY(__NR_fchmod, x0-1, x0); FAIL;
// __NR_fchown 95
GO(__NR_fchown, "3s 0m");
SY(__NR_fchown, x0, x0, x0); FAIL;
// __NR_getpriority 96
GO(__NR_getpriority, "2s 0m");
SY(__NR_getpriority, x0-1, x0); FAIL;
// __NR_setpriority 97
GO(__NR_setpriority, "3s 0m");
SY(__NR_setpriority, x0-1, x0, x0); FAIL;
// __NR_profil 98
GO(__NR_profil, "ni");
SY(__NR_profil); FAIL;
// __NR_statfs 99
GO(__NR_statfs, "2s 2m");
SY(__NR_statfs, x0, x0); FAIL;
// __NR_fstatfs 100
GO(__NR_fstatfs, "2s 1m");
SY(__NR_fstatfs, x0, x0); FAIL;
// __NR_ioperm 101
GO(__NR_ioperm, "3s 0m");
SY(__NR_ioperm, x0, x0, x0); FAIL;
// __NR_socketcall 102
GO(__NR_socketcall, "XXX");
// (XXX: need to do all sub-cases properly)
// __NR_syslog 103
GO(__NR_syslog, "3s 1m");
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); FAIL;
// __NR_getitimer 105
GO(__NR_getitimer, "2s 1m");
SY(__NR_getitimer, x0, x0, x0); FAIL;
// __NR_stat 106
GO(__NR_stat, "2s 2m");
SY(__NR_stat, x0, x0); FAIL;
// __NR_lstat 107
GO(__NR_lstat, "2s 2m");
SY(__NR_lstat, x0, x0); FAIL;
// __NR_fstat 108
GO(__NR_fstat, "2s 1m");
SY(__NR_fstat, x0, x0); FAIL;
// __NR_olduname 109
GO(__NR_olduname, "n/a");
// (obsolete, not handled by Valgrind)
// __NR_iopl 110
GO(__NR_iopl, "1s 0m");
SY(__NR_iopl, x0+100); FAIL;
// __NR_vhangup 111
GO(__NR_vhangup, "0s 0m");
SY(__NR_vhangup); SUCC_OR_FAIL; // Will succeed for superuser
// __NR_idle 112
GO(__NR_idle, "ni");
SY(__NR_idle); FAIL;
// __NR_vm86old 113
GO(__NR_vm86old, "n/a");
// (will probably never be handled by Valgrind)
// __NR_wait4 114
GO(__NR_wait4, "4s 2m");
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) FAIL;
// __NR_sysinfo 116
GO(__NR_sysinfo, "1s 1m");
SY(__NR_sysinfo, x0); FAIL;
// __NR_ipc 117
// XXX: This is simplistic -- need to do all the sub-cases properly.
// XXX: Also, should be 6 scalar errors, except glibc's syscall() doesn't
// use the 6th one!
GO(__NR_ipc, "5s 0m");
SY(__NR_ipc, x0+4, x0, x0, x0, x0, x0); FAIL;
// __NR_fsync 118
GO(__NR_fsync, "1s 0m");
SY(__NR_fsync, x0-1); FAIL;
// __NR_sigreturn 119
GO(__NR_sigreturn, "n/a");
//SY(__NR_sigreturn); // (Not yet handled by Valgrind) FAIL;
// __NR_clone 120
#ifndef CLONE_PARENT_SETTID
#define CLONE_PARENT_SETTID 0x00100000
#endif
// XXX: should really be "4s 2m"? Not sure... (see PRE(sys_clone))
GO(__NR_clone, "4s 0m");
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) FAIL;
// __NR_uname 122
GO(__NR_uname, "1s 1m");
SY(__NR_uname, x0); FAIL;
// __NR_modify_ldt 123
GO(__NR_modify_ldt, "3s 1m");
SY(__NR_modify_ldt, x0+1, x0, x0+1); FAILx(EINVAL);
// __NR_adjtimex 124
// XXX: need to do properly, but deref'ing NULL causing Valgrind to crash...
GO(__NR_adjtimex, "XXX");
// SY(__NR_adjtimex, x0); FAIL;
// __NR_mprotect 125
GO(__NR_mprotect, "3s 0m");
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]); SUCC;
// __NR_create_module 127
GO(__NR_create_module, "ni");
SY(__NR_create_module); FAIL;
// __NR_init_module 128
GO(__NR_init_module, "3s 2m");
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) FAIL;
// __NR_get_kernel_syms 130
GO(__NR_get_kernel_syms, "ni");
SY(__NR_get_kernel_syms); FAIL;
// __NR_quotactl 131
GO(__NR_quotactl, "4s 1m");
SY(__NR_quotactl, x0, x0, x0, x0); FAIL;
// __NR_getpgid 132
GO(__NR_getpgid, "1s 0m");
SY(__NR_getpgid, x0-1); FAIL;
// __NR_fchdir 133
GO(__NR_fchdir, "1s 0m");
SY(__NR_fchdir, x0-1); FAIL;
// __NR_bdflush 134
GO(__NR_bdflush, "n/a");
//SY(__NR_bdflush); // (Not yet handled by Valgrind) FAIL;
// __NR_sysfs 135
GO(__NR_sysfs, "n/a");
//SY(__NR_sysfs); // (Not yet handled by Valgrind) FAIL;
// __NR_personality 136
GO(__NR_personality, "1s 0m");
SY(__NR_personality, x0+0xffffffff); SUCC;
// __NR_afs_syscall 137
GO(__NR_afs_syscall, "ni");
SY(__NR_afs_syscall); FAIL;
// __NR_setfsuid 138
GO(__NR_setfsuid, "1s 0m");
SY(__NR_setfsuid, x0); SUCC; // This syscall has a stupid return value
// __NR_setfsgid 139
GO(__NR_setfsgid, "1s 0m");
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); FAIL;
// __NR_getdents 141
GO(__NR_getdents, "3s 1m");
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); FAIL;
// __NR_flock 143
GO(__NR_flock, "2s 0m");
SY(__NR_flock, x0, x0); FAIL;
// __NR_msync 144
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); FAIL;
// __NR_writev 146
GO(__NR_writev, "3s 1m");
SY(__NR_writev, x0, x0, x0+1); FAIL;
// __NR_getsid 147
GO(__NR_getsid, "1s 0m");
SY(__NR_getsid, x0-1); FAIL;
// __NR_fdatasync 148
GO(__NR_fdatasync, "1s 0m");
SY(__NR_fdatasync, x0-1); FAIL;
// __NR__sysctl 149
GO(__NR__sysctl, "1s 1m");
SY(__NR__sysctl, x0); FAIL;
// __NR_mlock 150
GO(__NR_mlock, "2s 0m");
SY(__NR_mlock, x0, x0+1); FAIL;
// __NR_munlock 151
GO(__NR_munlock, "2s 0m");
SY(__NR_munlock, x0, x0+1); FAIL;
// __NR_mlockall 152
GO(__NR_mlockall, "1s 0m");
SY(__NR_mlockall, x0-1); FAIL;
// __NR_munlockall 153
GO(__NR_munlockall, "0s 0m");
SY(__NR_munlockall); SUCC_OR_FAILx(EPERM);
// __NR_sched_setparam 154
GO(__NR_sched_setparam, "2s 1m");
SY(__NR_sched_setparam, x0, x0); FAIL;
// __NR_sched_getparam 155
GO(__NR_sched_getparam, "2s 1m");
SY(__NR_sched_getparam, x0, x0); FAIL;
// __NR_sched_setscheduler 156
GO(__NR_sched_setscheduler, "3s 1m");
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-1); FAIL;
// __NR_sched_yield 158
GO(__NR_sched_yield, "0s 0m");
SY(__NR_sched_yield); SUCC;
// __NR_sched_get_priority_max 159
GO(__NR_sched_get_priority_max, "1s 0m");
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-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) FAIL;
// __NR_nanosleep 162
GO(__NR_nanosleep, "2s 2m");
SY(__NR_nanosleep, x0, x0+1); FAIL;
// __NR_mremap 163
GO(__NR_mremap, "5s 0m");
SY(__NR_mremap, x0+1, x0, x0, x0, x0); FAILx(EINVAL);
// __NR_setresuid 164
GO(__NR_setresuid, "3s 0m");
SY(__NR_setresuid, x0, x0, x0); FAIL;
// __NR_getresuid 165
GO(__NR_getresuid, "3s 3m");
SY(__NR_getresuid, x0, x0, x0); FAIL;
// __NR_vm86 166
GO(__NR_vm86, "n/a");
// (will probably never be handled by Valgrind)
// __NR_query_module 167
GO(__NR_query_module, "ni");
SY(__NR_query_module); FAIL;
// __NR_poll 168
GO(__NR_poll, "3s 1m");
SY(__NR_poll, x0, x0+1, x0); FAIL;
// __NR_nfsservctl 169
GO(__NR_nfsservctl, "n/a");
//SY(__NR_nfsservctl); // (Not yet handled by Valgrind) FAIL;
// __NR_setresgid 170
GO(__NR_setresgid, "3s 0m");
SY(__NR_setresgid, x0, x0, x0); FAIL;
// __NR_getresgid 171
GO(__NR_getresgid, "3s 3m");
SY(__NR_getresgid, x0, x0, x0); FAIL;
// __NR_prctl 172
GO(__NR_prctl, "5s 0m");
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) FAIL;
// __NR_rt_sigaction 174
GO(__NR_rt_sigaction, "4s 4m");
SY(__NR_rt_sigaction, x0, x0+&px[2], x0+&px[2], x0); FAIL;
// __NR_rt_sigprocmask 175
GO(__NR_rt_sigprocmask, "4s 2m");
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); FAIL;
// __NR_rt_sigtimedwait 177
GO(__NR_rt_sigtimedwait, "4s 3m");
SY(__NR_rt_sigtimedwait, x0+1, x0+1, x0+1, x0); FAIL;
// __NR_rt_sigqueueinfo 178
GO(__NR_rt_sigqueueinfo, "3s 1m");
SY(__NR_rt_sigqueueinfo, x0, x0+1, x0); FAIL;
// __NR_rt_sigsuspend 179
GO(__NR_rt_sigsuspend, "ignore");
// (I don't know how to test this...)
// __NR_pread64 180
GO(__NR_pread64, "5s 1m");
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); FAIL;
// __NR_chown 182
GO(__NR_chown, "3s 1m");
SY(__NR_chown, x0, x0, x0); FAIL;
// __NR_getcwd 183
GO(__NR_getcwd, "2s 1m");
SY(__NR_getcwd, x0, x0+1); FAIL;
// __NR_capget 184
GO(__NR_capget, "2s 2m");
SY(__NR_capget, x0, x0); FAIL;
// __NR_capset 185
GO(__NR_capset, "2s 2m");
SY(__NR_capset, x0, x0); FAIL;
// __NR_sigaltstack 186
{
struct our_sigaltstack {
void *ss_sp;
int ss_flags;
size_t ss_size;
} ss;
ss.ss_sp = NULL;
ss.ss_flags = 0;
ss.ss_size = 0;
VALGRIND_MAKE_NOACCESS(& ss, sizeof(struct our_sigaltstack));
GO(__NR_sigaltstack, "2s 2m");
SY(__NR_sigaltstack, x0+&ss, x0+&ss); SUCC;
}
// __NR_sendfile 187
GO(__NR_sendfile, "4s 1m");
SY(__NR_sendfile, x0, x0, x0+1, x0); FAIL;
// __NR_getpmsg 188
// Could do 5s 4m with more effort, but I can't be bothered for this
// crappy non-standard syscall.
GO(__NR_getpmsg, "5s 0m");
SY(__NR_getpmsg, x0, x0, x0, x0); FAIL;
// __NR_putpmsg 189
// Could do 5s 2m with more effort, but I can't be bothered for this
// crappy non-standard syscall.
GO(__NR_putpmsg, "5s 0m");
SY(__NR_putpmsg, x0, x0, x0, x0, x0); FAIL;
// __NR_vfork 190
GO(__NR_vfork, "other");
// (sse scalar_vfork.c)
// __NR_ugetrlimit 191
GO(__NR_ugetrlimit, "2s 1m");
SY(__NR_ugetrlimit, x0, x0); FAIL;
// __NR_mmap2 192
GO(__NR_mmap2, "5s 0m");
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); FAIL;
// __NR_ftruncate64 194
GO(__NR_ftruncate64, "3s 0m");
SY(__NR_ftruncate64, x0, x0, x0); FAIL;
// __NR_stat64 195
GO(__NR_stat64, "2s 2m");
SY(__NR_stat64, x0, x0); FAIL;
// __NR_lstat64 196
GO(__NR_lstat64, "2s 2m");
SY(__NR_lstat64, x0, x0); FAIL;
// __NR_fstat64 197
GO(__NR_fstat64, "2s 1m");
SY(__NR_fstat64, x0, x0); FAIL;
// __NR_lchown32 198
GO(__NR_lchown32, "3s 1m");
SY(__NR_lchown32, x0, x0, x0); FAIL;
// __NR_getuid32 199
GO(__NR_getuid32, "0s 0m");
SY(__NR_getuid32); SUCC;
// __NR_getgid32 200
GO(__NR_getgid32, "0s 0m");
SY(__NR_getgid32); SUCC;
// __NR_geteuid32 201
GO(__NR_geteuid32, "0s 0m");
SY(__NR_geteuid32); SUCC;
// __NR_getegid32 202
GO(__NR_getegid32, "0s 0m");
SY(__NR_getegid32); SUCC;
// __NR_setreuid32 203
GO(__NR_setreuid32, "2s 0m");
SY(__NR_setreuid32, x0, x0); FAIL;
// __NR_setregid32 204
GO(__NR_setregid32, "2s 0m");
SY(__NR_setregid32, x0, x0); FAIL;
// __NR_getgroups32 205
GO(__NR_getgroups32, "2s 1m");
SY(__NR_getgroups32, x0+1, x0+1); FAIL;
// __NR_setgroups32 206
GO(__NR_setgroups32, "2s 1m");
SY(__NR_setgroups32, x0+1, x0+1); FAIL;
// __NR_fchown32 207
GO(__NR_fchown32, "3s 0m");
SY(__NR_fchown32, x0, x0, x0); FAIL;
// __NR_setresuid32 208
GO(__NR_setresuid32, "3s 0m");
SY(__NR_setresuid32, x0, x0, x0); FAIL;
// __NR_getresuid32 209
GO(__NR_getresuid32, "3s 3m");
SY(__NR_getresuid32, x0, x0, x0); FAIL;
// __NR_setresgid32 210
GO(__NR_setresgid32, "3s 0m");
SY(__NR_setresgid32, x0, x0, x0); FAIL;
// __NR_getresgid32 211
GO(__NR_getresgid32, "3s 3m");
SY(__NR_getresgid32, x0, x0, x0); FAIL;
// __NR_chown32 212
GO(__NR_chown32, "3s 1m");
SY(__NR_chown32, x0, x0, x0); FAIL;
// __NR_setuid32 213
GO(__NR_setuid32, "1s 0m");
SY(__NR_setuid32, x0); FAIL;
// __NR_setgid32 214
GO(__NR_setgid32, "1s 0m");
SY(__NR_setgid32, x0); FAIL;
// __NR_setfsuid32 215
GO(__NR_setfsuid32, "1s 0m");
SY(__NR_setfsuid32, x0); SUCC; // This syscall has a stupid return value
// __NR_setfsgid32 216
GO(__NR_setfsgid32, "1s 0m");
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) FAIL;
// __NR_mincore 218
GO(__NR_mincore, "3s 1m");
SY(__NR_mincore, x0, x0+40960, x0); FAIL;
// __NR_madvise 219
GO(__NR_madvise, "3s 0m");
SY(__NR_madvise, x0, x0+1, x0); FAILx(ENOMEM);
// __NR_getdents64 220
GO(__NR_getdents64, "3s 1m");
SY(__NR_getdents64, x0, x0, x0+1); FAIL;
// __NR_fcntl64 221
// As with sys_open(), the 'fd' error is suppressed for the later ones.
// For F_GETFD the 3rd arg is ignored
GO(__NR_fcntl64, "(GETFD) 2s 0m");
SY(__NR_fcntl64, x0-1, x0+F_GETFD, x0); FAILx(EBADF);
// For F_DUPFD the 3rd arg is 'arg'
GO(__NR_fcntl64, "(DUPFD) 1s 0m");
SY(__NR_fcntl64, x0-1, x0+F_DUPFD, x0); FAILx(EBADF);
// For F_GETLK the 3rd arg is 'lock'
// on x86, this fails with EBADF. But on amd64 in 32-bit mode
// it fails with EFAULT.
GO(__NR_fcntl64, "(GETLK) 1s 0m");
SY(__NR_fcntl64, x0-1, x0+F_GETLK, x0); FAIL; //FAILx(EBADF);
// 222
GO(222, "ni");
SY(222); FAIL;
// 223
GO(223, "ni");
SY(223); FAIL;
// __NR_gettid 224
GO(__NR_gettid, "n/a");
//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) FAIL;
// __NR_setxattr 226
GO(__NR_setxattr, "5s 3m");
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); FAIL;
// __NR_fsetxattr 228
GO(__NR_fsetxattr, "5s 2m");
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); FAIL;
// __NR_lgetxattr 230
GO(__NR_lgetxattr, "4s 3m");
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); FAIL;
// __NR_listxattr 232
GO(__NR_listxattr, "3s 2m");
SY(__NR_listxattr, x0, x0, x0+1); FAIL;
// __NR_llistxattr 233
GO(__NR_llistxattr, "3s 2m");
SY(__NR_llistxattr, x0, x0, x0+1); FAIL;
// __NR_flistxattr 234
GO(__NR_flistxattr, "3s 1m");
SY(__NR_flistxattr, x0-1, x0, x0+1); FAIL; /* kernel returns EBADF, but both seem correct */
// __NR_removexattr 235
GO(__NR_removexattr, "2s 2m");
SY(__NR_removexattr, x0, x0); FAIL;
// __NR_lremovexattr 236
GO(__NR_lremovexattr, "2s 2m");
SY(__NR_lremovexattr, x0, x0); FAIL;
// __NR_fremovexattr 237
GO(__NR_fremovexattr, "2s 1m");
SY(__NR_fremovexattr, x0, x0); FAIL;
// __NR_tkill 238
GO(__NR_tkill, "n/a");
//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); FAIL;
// __NR_futex 240
#ifndef FUTEX_WAIT
#define FUTEX_WAIT 0
#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); FAIL;
// __NR_sched_setaffinity 241
GO(__NR_sched_setaffinity, "3s 1m");
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); FAIL;
// __NR_set_thread_area 243
GO(__NR_set_thread_area, "1s 1m");
SY(__NR_set_thread_area, x0); FAILx(EFAULT);
// __NR_get_thread_area 244
GO(__NR_get_thread_area, "1s 1m");
SY(__NR_get_thread_area, x0); FAILx(EFAULT);
// __NR_io_setup 245
GO(__NR_io_setup, "2s 1m");
SY(__NR_io_setup, x0, x0); FAIL;
// __NR_io_destroy 246
{
// jump through hoops to prevent the PRE(io_destroy) wrapper crashing.
struct fake_aio_ring {
unsigned id; /* kernel internal index number */
unsigned nr; /* number of io_events */
// There are more fields in the real aio_ring, but the 'nr' field is
// the only one used by the PRE() wrapper.
} ring = { 0, 0 };
struct fake_aio_ring* ringptr = ˚
GO(__NR_io_destroy, "1s 0m");
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); FAIL;
// __NR_io_submit 248
GO(__NR_io_submit, "3s 1m");
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); FAIL;
// __NR_fadvise64 250
GO(__NR_fadvise64, "n/a");
//SY(__NR_fadvise64); // (Not yet handled by Valgrind) FAIL;
// 251
GO(251, "ni");
SY(251); FAIL;
// __NR_exit_group 252
GO(__NR_exit_group, "other");
// (see scalar_exit_group.c)
// __NR_lookup_dcookie 253
GO(__NR_lookup_dcookie, "4s 1m");
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); SUCC_OR_FAIL;
// __NR_epoll_ctl 255
GO(__NR_epoll_ctl, "4s 1m");
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); FAIL;
// __NR_remap_file_pages 257
GO(__NR_remap_file_pages, "n/a");
//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); SUCC_OR_FAILx(ENOSYS);
// __NR_timer_create 259
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, "4s 2m");
SY(__NR_timer_settime, x0, x0, x0, x0+1); FAIL;
// __NR_timer_gettime (__NR_timer_create+2)
GO(__NR_timer_gettime, "2s 1m");
SY(__NR_timer_gettime, x0, x0); FAIL;
// __NR_timer_getoverrun (__NR_timer_create+3)
GO(__NR_timer_getoverrun, "1s 0m");
SY(__NR_timer_getoverrun, x0); FAIL;
// __NR_timer_delete (__NR_timer_create+4)
GO(__NR_timer_delete, "1s 0m");
SY(__NR_timer_delete, x0); FAIL;
// __NR_clock_settime (__NR_timer_create+5)
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, "2s 1m");
SY(__NR_clock_gettime, x0, x0); FAIL;
// __NR_clock_getres (__NR_timer_create+7)
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, "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); FAIL;
// __NR_fstatfs64 269
GO(__NR_fstatfs64, "3s 1m");
SY(__NR_fstatfs64, x0, x0+1, x0); FAIL;
// __NR_tgkill 270
GO(__NR_tgkill, "n/a");
//SY(__NR_tgkill); // (Not yet handled by Valgrind) FAIL;
// __NR_utimes 271
GO(__NR_utimes, "2s 2m");
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) FAIL;
// __NR_vserver 273
GO(__NR_vserver, "ni");
SY(__NR_vserver); FAIL;
// __NR_mbind 274
GO(__NR_mbind, "n/a");
//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) FAIL;
// __NR_set_mempolicy 276
GO(__NR_set_mempolicy, "n/a");
//SY(__NR_set_mempolicy); // (Not yet handled by Valgrind) FAIL;
// __NR_mq_open 277
GO(__NR_mq_open, "4s 3m");
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); 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); 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); FAIL;
// __NR_mq_notify (__NR_mq_open+4)
GO(__NR_mq_notify, "2s 1m");
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); FAIL;
// __NR_sys_kexec_load 283
GO(__NR_sys_kexec_load, "ni");
SY(__NR_sys_kexec_load); FAIL;
// no such syscall...
GO(9999, "1e");
SY(9999); FAIL;
// __NR_exit 1
GO(__NR_exit, "1s 0m");
SY(__NR_exit, x0); FAIL;
assert(0);
}
