mirror of
https://github.com/reactos/syzkaller.git
synced 2024-11-25 04:19:53 +00:00
f01cb93788
We don't need compiler support for such things anymore, now we simply can do: type signalno int32[0:65]
368 lines
9.0 KiB
Plaintext
368 lines
9.0 KiB
Plaintext
# Copyright 2017 syzkaller project authors. All rights reserved.
|
|
# Use of this source code is governed by Apache 2 LICENSE that can be found in the LICENSE file.
|
|
|
|
include <sys/types.h>
|
|
include <sys/mman.h>
|
|
include <sys/stat.h>
|
|
include <fcntl.h>
|
|
include <unistd.h>
|
|
include <sys/time.h>
|
|
include <dirent.h>
|
|
include <poll.h>
|
|
include <sys/select.h>
|
|
include <sys/param.h>
|
|
include <sys/resource.h>
|
|
include <time.h>
|
|
include <signal.h>
|
|
include <sys/wait.h>
|
|
|
|
pipe(pipefd ptr[out, pipefd])
|
|
|
|
stat(file ptr[in, filename], statbuf ptr[out, stat])
|
|
lstat(file ptr[in, filename], statbuf ptr[out, stat])
|
|
|
|
poll(fds ptr[in, array[pollfd]], nfds len[fds], timeout int32)
|
|
select(n len[inp], inp ptr[inout, fd_set], outp ptr[inout, fd_set], exp ptr[inout, fd_set], tvp ptr[inout, timeval])
|
|
|
|
mincore(addr vma, size len[addr], vec buffer[out])
|
|
|
|
fcntl$dupfd(fd fd, cmd flags[fcntl_dupfd], arg fd) fd
|
|
fcntl$getflags(fd fd, cmd flags[fcntl_getflags])
|
|
fcntl$setflags(fd fd, cmd const[F_SETFD], flags flags[fcntl_flags])
|
|
fcntl$setstatus(fd fd, cmd const[F_SETFL], flags flags[fcntl_status])
|
|
fcntl$lock(fd fd, cmd flags[fcntl_lock], lock ptr[in, flock])
|
|
fcntl$getown(fd fd, cmd const[F_GETOWN]) pid
|
|
fcntl$setown(fd fd, cmd const[F_SETOWN], pid pid)
|
|
|
|
mknod(file ptr[in, filename], mode flags[mknod_mode], dev int32)
|
|
mknod$loop(file ptr[in, filename], mode flags[mknod_mode], dev proc[1792, 2])
|
|
mknodat(dirfd fd_dir, file ptr[in, filename], mode flags[mknod_mode], dev int32)
|
|
chmod(file ptr[in, filename], mode flags[open_mode])
|
|
fchmod(fd fd, mode flags[open_mode])
|
|
fchmodat(dirfd fd_dir, file ptr[in, filename], mode flags[open_mode], flags flags[at_flags])
|
|
chown(file ptr[in, filename], uid uid, gid gid)
|
|
lchown(file ptr[in, filename], uid uid, gid gid)
|
|
fchown(fd fd, uid uid, gid gid)
|
|
fchownat(dirfd fd_dir, file ptr[in, filename], uid uid, gid gid, flags flags[at_flags])
|
|
faccessat(dirfd fd_dir, pathname ptr[in, filename], mode flags[open_mode], flags flags[faccessat_flags])
|
|
utimes(filename ptr[in, filename], times ptr[in, itimerval])
|
|
utimensat(dir fd_dir, pathname ptr[in, filename], times ptr[in, itimerval], flags flags[utimensat_flags])
|
|
|
|
execve(file ptr[in, filename], argv ptr[in, array[ptr[in, string]]], envp ptr[in, array[ptr[in, string]]])
|
|
|
|
getgid() gid
|
|
getegid() gid
|
|
setuid(uid uid)
|
|
setgid(gid gid)
|
|
seteuid(euid uid)
|
|
setegid(egid gid)
|
|
getuid() uid
|
|
geteuid() uid
|
|
setpgid(pid pid, pgid pid)
|
|
getpgid(pid pid) pid
|
|
getpgrp() pid
|
|
getpid() pid
|
|
getppid() pid
|
|
setreuid(ruid uid, euid uid)
|
|
setregid(rgid gid, egid gid)
|
|
getgroups(size len[list], list ptr[inout, array[gid]])
|
|
setgroups(size len[list], list ptr[in, array[gid]])
|
|
|
|
link(old ptr[in, filename], new ptr[in, filename])
|
|
linkat(oldfd fd_dir, old ptr[in, filename], newfd fd_dir, new ptr[in, filename], flags flags[linkat_flags])
|
|
symlinkat(old ptr[in, filename], newfd fd_dir, new ptr[in, filename])
|
|
symlink(old ptr[in, filename], new ptr[in, filename])
|
|
unlink(path ptr[in, filename])
|
|
unlinkat(fd fd_dir, path ptr[in, filename], flags flags[unlinkat_flags])
|
|
readlink(path ptr[in, filename], buf buffer[out], siz len[buf])
|
|
readlinkat(fd fd_dir, path ptr[in, filename], buf buffer[out], siz len[buf])
|
|
rename(old ptr[in, filename], new ptr[in, filename])
|
|
renameat(oldfd fd_dir, old ptr[in, filename], newfd fd_dir, new ptr[in, filename])
|
|
mkdir(path ptr[in, filename], mode flags[open_mode])
|
|
mkdirat(fd fd_dir, path ptr[in, filename], mode flags[open_mode])
|
|
rmdir(path ptr[in, filename])
|
|
truncate(file ptr[in, filename], len intptr)
|
|
ftruncate(fd fd, len intptr)
|
|
flock(fd fd, op flags[flock_op])
|
|
fsync(fd fd)
|
|
fdatasync(fd fd)
|
|
sync()
|
|
getdents(fd fd_dir, ent buffer[out], count len[ent])
|
|
chroot(dir ptr[in, filename])
|
|
fchroot(fd fd)
|
|
chdir(dir ptr[in, filename])
|
|
fchdir(fd fd)
|
|
|
|
getrusage(who flags[rusage_who], usage ptr[out, rusage])
|
|
getrlimit(res flags[rlimit_type], rlim ptr[out, rlimit])
|
|
setrlimit(res flags[rlimit_type], rlim ptr[in, rlimit])
|
|
|
|
clock_gettime(id flags[clock_id], tp ptr[out, timespec])
|
|
clock_settime(id flags[clock_id], tp ptr[in, timespec])
|
|
clock_getres(id flags[clock_id], tp ptr[out, timespec])
|
|
clock_nanosleep(id flags[clock_id], flags flags[timer_flags], rqtp ptr[in, timespec], rmtp ptr[out, timespec, opt])
|
|
nanosleep(req ptr[in, timespec], rem ptr[out, timespec, opt])
|
|
getitimer(which flags[getitimer_which], cur ptr[out, itimerval])
|
|
setitimer(which flags[getitimer_which], new ptr[in, itimerval], old ptr[out, itimerval, opt])
|
|
wait4(pid pid, status ptr[out, int32, opt], options flags[wait_options], ru ptr[out, rusage, opt])
|
|
|
|
pollfd {
|
|
fd fd
|
|
events flags[pollfd_events, int16]
|
|
revents const[0, int16]
|
|
}
|
|
|
|
sigset {
|
|
mask int64
|
|
}
|
|
|
|
sigset_size {
|
|
ss ptr[inout, sigset]
|
|
len len[ss, intptr]
|
|
}
|
|
|
|
resource time_sec[intptr]
|
|
resource time_nsec[intptr]
|
|
resource time_usec[intptr]
|
|
|
|
# prog knowns about this struct type
|
|
timespec {
|
|
sec intptr
|
|
nsec intptr
|
|
}
|
|
|
|
# prog knowns about this struct type
|
|
timeval {
|
|
sec intptr
|
|
usec intptr
|
|
}
|
|
|
|
statx_timestamp {
|
|
sec int64
|
|
nsec int32
|
|
__reserved int32
|
|
}
|
|
|
|
itimerspec {
|
|
interv timespec
|
|
value timespec
|
|
}
|
|
|
|
itimerval {
|
|
interv timeval
|
|
value timeval
|
|
}
|
|
|
|
utimbuf {
|
|
actime intptr
|
|
modtime intptr
|
|
}
|
|
|
|
io_event {
|
|
data int64
|
|
obj int64
|
|
res int64
|
|
res2 int32
|
|
}
|
|
|
|
cap_header {
|
|
var flags[cap_version, int32]
|
|
pid pid
|
|
}
|
|
|
|
cap_data {
|
|
eff0 int32
|
|
perm0 int32
|
|
inher0 int32
|
|
eff1 int32
|
|
perm1 int32
|
|
inher1 int32
|
|
}
|
|
|
|
# TODO: fd_set needs to be a separate type
|
|
fd_set {
|
|
mask0 int64
|
|
mask1 int64
|
|
mask2 int64
|
|
mask3 int64
|
|
mask4 int64
|
|
mask5 int64
|
|
mask6 int64
|
|
mask7 int64
|
|
}
|
|
|
|
sock_fprog {
|
|
len len[filter, int16]
|
|
filter ptr[in, array[sock_filter]]
|
|
}
|
|
|
|
sock_filter {
|
|
code int16
|
|
jt int8
|
|
jf int8
|
|
k int32
|
|
}
|
|
|
|
file_handle {
|
|
bytes len[parent, int32]
|
|
type int32
|
|
handle array[int8]
|
|
}
|
|
|
|
mq_attr {
|
|
flags intptr
|
|
maxmsg intptr
|
|
msgsize intptr
|
|
curmsg intptr
|
|
res0 intptr
|
|
res1 intptr
|
|
res2 intptr
|
|
res3 intptr
|
|
}
|
|
|
|
kexec_segment {
|
|
buf buffer[in]
|
|
sz len[buf, intptr]
|
|
# TODO: this is address in kernel
|
|
mem intptr
|
|
memsz intptr
|
|
}
|
|
|
|
robust_list {
|
|
next vma
|
|
off intptr
|
|
pend vma
|
|
}
|
|
|
|
rusage {
|
|
utime timeval
|
|
stime timeval
|
|
maxrss intptr
|
|
ixrss intptr
|
|
idrss intptr
|
|
isrss intptr
|
|
minflt intptr
|
|
majflt intptr
|
|
nswap intptr
|
|
inblock intptr
|
|
oublock intptr
|
|
msgsnd intptr
|
|
msgrcv intptr
|
|
signals intptr
|
|
nvcsw intptr
|
|
nivcsw intptr
|
|
}
|
|
|
|
rlimit {
|
|
soft intptr
|
|
hard intptr
|
|
}
|
|
|
|
tms {
|
|
utime intptr
|
|
stime intptr
|
|
cutime intptr
|
|
cstime intptr
|
|
}
|
|
|
|
timex {
|
|
stuff0 intptr
|
|
stuff1 intptr
|
|
stuff2 intptr
|
|
stuff3 intptr
|
|
stuff4 intptr
|
|
stuff5 intptr
|
|
stuff6 intptr
|
|
stuff7 intptr
|
|
stuff8 intptr
|
|
stuff9 intptr
|
|
stuff10 intptr
|
|
stuff11 intptr
|
|
stuff12 intptr
|
|
stuff13 intptr
|
|
stuff14 intptr
|
|
stuff15 intptr
|
|
stuff16 intptr
|
|
stuff17 intptr
|
|
stuff18 intptr
|
|
stuff19 intptr
|
|
stuff20 intptr
|
|
stuff21 intptr
|
|
stuff22 intptr
|
|
stuff23 intptr
|
|
stuff24 intptr
|
|
stuff25 intptr
|
|
}
|
|
|
|
ustat {
|
|
free int32
|
|
inode intptr
|
|
nampac0 int32
|
|
nampac1 int32
|
|
nampac2 int32
|
|
}
|
|
|
|
user_desc {
|
|
entry_number int32
|
|
# Base should be vma and limit should be len[base]
|
|
# But these fields are int32, so we can't use vma.
|
|
base_addr flags[user_desc_bases, int32]
|
|
limit flags[user_desc_limits, int32]
|
|
seg_32bit int32:1
|
|
contents int32:2
|
|
read_exec_only int32:1
|
|
limit_in_pages int32:1
|
|
seg_not_present int32:1
|
|
useable int32:1
|
|
lm int32:1
|
|
}
|
|
|
|
user_desc_bases = 0, 4096, 1048576, 536870912, 536872960, 536875008, 0xffffffff
|
|
user_desc_limits = 0, 1024, 4096, 8192, 16384, 0xffffffff
|
|
|
|
flock {
|
|
type flags[flock_type, int16]
|
|
whence flags[seek_whence, int16]
|
|
start intptr
|
|
len intptr
|
|
pid pid
|
|
}
|
|
|
|
linger {
|
|
onoff int32
|
|
linger int32
|
|
}
|
|
|
|
ucred {
|
|
pid pid
|
|
uid uid
|
|
gid gid
|
|
}
|
|
|
|
fadvise_flags = POSIX_FADV_NORMAL, POSIX_FADV_SEQUENTIAL, POSIX_FADV_RANDOM, POSIX_FADV_NOREUSE, POSIX_FADV_WILLNEED, POSIX_FADV_DONTNEED
|
|
clock_type = CLOCK_REALTIME, CLOCK_MONOTONIC, CLOCK_PROCESS_CPUTIME_ID, CLOCK_THREAD_CPUTIME_ID
|
|
cap_version = 0x19980330, 0x20071026, 0x20080522
|
|
pollfd_events = POLLIN, POLLPRI, POLLOUT, POLLERR, POLLHUP, POLLNVAL, POLLRDNORM, POLLRDBAND, POLLWRNORM, POLLWRBAND
|
|
mknod_mode = S_IFREG, S_IFCHR, S_IFBLK, S_IFIFO, S_IFSOCK, S_IRUSR, S_IWUSR, S_IXUSR, S_IRGRP, S_IWGRP, S_IXGRP, S_IROTH, S_IWOTH, S_IXOTH
|
|
at_flags = AT_SYMLINK_NOFOLLOW, AT_SYMLINK_FOLLOW
|
|
linkat_flags = AT_SYMLINK_FOLLOW
|
|
unlinkat_flags = 0, AT_REMOVEDIR
|
|
flock_op = LOCK_SH, LOCK_EX, LOCK_UN, LOCK_NB
|
|
faccessat_flags = AT_EACCESS, AT_SYMLINK_NOFOLLOW
|
|
rusage_who = RUSAGE_SELF, RUSAGE_CHILDREN
|
|
rlimit_type = RLIMIT_AS, RLIMIT_CORE, RLIMIT_CPU, RLIMIT_DATA, RLIMIT_FSIZE, RLIMIT_MEMLOCK, RLIMIT_NOFILE, RLIMIT_NPROC, RLIMIT_RSS, RLIMIT_STACK, RLIMIT_NTHR, RLIMIT_STACK
|
|
clock_id = CLOCK_REALTIME, CLOCK_MONOTONIC, CLOCK_PROCESS_CPUTIME_ID, CLOCK_THREAD_CPUTIME_ID, CLOCK_VIRTUAL, CLOCK_PROF
|
|
sigprocmask_how = SIG_BLOCK, SIG_UNBLOCK, SIG_SETMASK
|
|
getitimer_which = ITIMER_REAL, ITIMER_VIRTUAL, ITIMER_PROF, ITIMER_MONOTONIC
|
|
wait_options = WALLSIG, WALTSIG, WCONTINUED, WEXITED, WNOHANG, WNOZOMBIE, WSTOPPED, WTRAPPED, WUNTRACED
|
|
waitid_which = P_PID, P_PGID, P_ALL
|
|
timer_flags = 0, TIMER_ABSTIME
|
|
utimensat_flags = 0, AT_SYMLINK_NOFOLLOW
|
|
priority_which = PRIO_PROCESS, PRIO_PGRP, PRIO_USER
|
|
fcntl_dupfd = F_DUPFD, F_DUPFD_CLOEXEC
|
|
fcntl_getflags = F_GETFD, F_GETFL
|
|
fcntl_lock = F_SETLK, F_SETLKW, F_GETLK
|
|
fcntl_flags = FD_CLOEXEC
|
|
fcntl_status = O_APPEND, O_ASYNC, O_NONBLOCK, O_DSYNC, O_RSYNC, O_ALT_IO, O_DIRECT, O_NOSIGPIPE
|
|
flock_type = F_RDLCK, F_WRLCK, F_UNLCK
|