mirror of
https://github.com/reactos/syzkaller.git
synced 2024-11-24 03:49:45 +00:00
1066 lines
47 KiB
Plaintext
1066 lines
47 KiB
Plaintext
# Copyright 2015 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.
|
|
|
|
# Description of syscall arguments. See README.md for details.
|
|
|
|
include <linux/socket.h>
|
|
include <linux/ptrace.h>
|
|
include <linux/fanotify.h>
|
|
include <linux/inotify.h>
|
|
include <linux/resource.h>
|
|
include <linux/stat.h>
|
|
include <linux/mman.h>
|
|
include <linux/time.h>
|
|
include <linux/prctl.h>
|
|
include <linux/mount.h>
|
|
include <linux/fs.h>
|
|
include <linux/eventpoll.h>
|
|
include <linux/signalfd.h>
|
|
include <linux/eventfd.h>
|
|
include <linux/timerfd.h>
|
|
include <linux/personality.h>
|
|
include <linux/wait.h>
|
|
include <linux/user.h>
|
|
include <linux/un.h>
|
|
include <linux/ioctl.h>
|
|
include <linux/fadvise.h>
|
|
include <linux/falloc.h>
|
|
include <linux/futex.h>
|
|
include <linux/kexec.h>
|
|
include <linux/seccomp.h>
|
|
include <linux/elf.h>
|
|
include <linux/fiemap.h>
|
|
include <linux/kd.h>
|
|
include <linux/vt.h>
|
|
include <linux/if_alg.h>
|
|
include <linux/nfc.h>
|
|
include <linux/sockios.h>
|
|
include <linux/net_tstamp.h>
|
|
include <linux/termios.h>
|
|
include <linux/fcntl.h>
|
|
include <linux/sched.h>
|
|
include <linux/mqueue.h>
|
|
include <linux/mempolicy.h>
|
|
include <linux/in.h>
|
|
include <linux/ip.h>
|
|
include <linux/tcp.h>
|
|
include <linux/udp.h>
|
|
include <linux/kcmp.h>
|
|
include <linux/syslog.h>
|
|
include <uapi/linux/memfd.h>
|
|
include <uapi/linux/module.h>
|
|
include <asm/prctl.h>
|
|
include <linux/ioprio.h>
|
|
include <linux/membarrier.h>
|
|
include <uapi/linux/kcov.h>
|
|
include <uapi/linux/membarrier.h>
|
|
|
|
resource fd[int32]: 0xffffffffffffffff, AT_FDCWD
|
|
resource fd_dir[fd]
|
|
|
|
type signalno int32[0:65]
|
|
|
|
open(file ptr[in, filename], flags flags[open_flags], mode flags[open_mode]) fd
|
|
# Just so that we have something that creates fd_dir resources.
|
|
open$dir(file ptr[in, filename], flags flags[open_flags], mode flags[open_mode]) fd_dir
|
|
openat$dir(fd const[AT_FDCWD], file ptr[in, filename], flags flags[open_flags], mode flags[open_mode]) fd_dir
|
|
openat(fd fd_dir[opt], file ptr[in, filename], flags flags[open_flags], mode flags[open_mode]) fd
|
|
creat(file ptr[in, filename], mode flags[open_mode]) fd
|
|
close(fd fd)
|
|
read(fd fd, buf buffer[out], count len[buf])
|
|
pread64(fd fd, buf buffer[out], count len[buf], pos fileoff)
|
|
readv(fd fd, vec ptr[in, array[iovec_out]], vlen len[vec])
|
|
preadv(fd fd, vec ptr[in, array[iovec_out]], vlen len[vec], off fileoff)
|
|
write(fd fd, buf buffer[in], count len[buf])
|
|
pwrite64(fd fd, buf buffer[in], count len[buf], pos fileoff)
|
|
writev(fd fd, vec ptr[in, array[iovec_in]], vlen len[vec])
|
|
pwritev(fd fd, vec ptr[in, array[iovec_in]], vlen len[vec], off fileoff)
|
|
lseek(fd fd, offset fileoff, whence flags[seek_whence])
|
|
|
|
dup(oldfd fd) fd
|
|
dup2(oldfd fd, newfd fd) fd
|
|
dup3(oldfd fd, newfd fd, flags flags[dup_flags]) fd
|
|
|
|
pipe(pipefd ptr[out, pipefd])
|
|
pipe2(pipefd ptr[out, pipefd], flags flags[pipe_flags])
|
|
|
|
tee(fdin fd, fdout fd, len intptr, f flags[splice_flags])
|
|
splice(fdin fd, offin ptr[in, fileoff[int64]], fdout fd, offout ptr[in, fileoff[int64]], len intptr, f flags[splice_flags])
|
|
vmsplice(fd fd, vec ptr[in, array[iovec_in]], vlen len[vec], f flags[splice_flags])
|
|
sendfile(fdout fd, fdin fd, off ptr[inout, fileoff[intptr], opt], count intptr)
|
|
sendfile64(fdout fd, fdin fd, off ptr[inout, fileoff[int64], opt], count intptr)
|
|
|
|
stat(file ptr[in, filename], statbuf ptr[out, stat])
|
|
statx(fd fd_dir, file ptr[in, filename], flags flags[statx_flags], mask flags[statx_mask], statxbuf ptr[out, statx])
|
|
lstat(file ptr[in, filename], statbuf ptr[out, stat])
|
|
fstat(fd fd, statbuf ptr[out, stat])
|
|
|
|
poll(fds ptr[in, array[pollfd]], nfds len[fds], timeout int32)
|
|
ppoll(fds ptr[in, array[pollfd]], nfds len[fds], tsp ptr[in, timespec], sigmask ptr[in, sigset], size len[sigmask])
|
|
select(n len[inp], inp ptr[inout, fd_set], outp ptr[inout, fd_set], exp ptr[inout, fd_set], tvp ptr[inout, timeval])
|
|
pselect6(n len[inp], inp ptr[inout, fd_set], outp ptr[inout, fd_set], exp ptr[inout, fd_set], tvp ptr[inout, timespec], sig ptr[in, sigset_size])
|
|
|
|
resource fd_epoll[fd]
|
|
epoll_create(size int32) fd_epoll
|
|
epoll_create1(flags flags[epoll_flags]) fd_epoll
|
|
epoll_ctl$EPOLL_CTL_ADD(epfd fd_epoll, op const[EPOLL_CTL_ADD], fd fd, ev ptr[in, epoll_event])
|
|
epoll_ctl$EPOLL_CTL_MOD(epfd fd_epoll, op const[EPOLL_CTL_MOD], fd fd, ev ptr[in, epoll_event])
|
|
epoll_ctl$EPOLL_CTL_DEL(epfd fd_epoll, op const[EPOLL_CTL_DEL], fd fd)
|
|
epoll_wait(epfd fd_epoll, events ptr[out, array[epoll_event]], maxevents len[events], timeout int32)
|
|
epoll_pwait(epfd fd_epoll, events ptr[out, array[epoll_event]], maxevents len[events], timeout int32, sigmask ptr[in, sigset], size len[sigmask])
|
|
|
|
resource fd_signal[fd]
|
|
resource fd_timer[fd]
|
|
signalfd(fd fd, mask ptr[in, sigset], size len[mask]) fd_signal
|
|
signalfd4(fd fd, mask ptr[in, sigset], size len[mask], flags flags[signalfd_flags]) fd_signal
|
|
timerfd_create(clockid flags[clock_type], flags flags[timerfd_create_flags]) fd_timer
|
|
timerfd_settime(fd fd_timer, flags flags[timerfd_settime_flags], new ptr[in, itimerspec], old ptr[out, itimerspec])
|
|
timerfd_gettime(fd fd_timer, cur ptr[out, itimerspec])
|
|
|
|
resource fd_event[fd]
|
|
eventfd(initval int32) fd_event
|
|
eventfd2(initval int32, flags flags[eventfd_flags]) fd_event
|
|
read$eventfd(fd fd_event, val ptr[out, int64], len len[val])
|
|
write$eventfd(fd fd_event, val ptr[in, int64], len len[val])
|
|
|
|
mmap(addr vma, len len[addr], prot flags[mmap_prot], flags flags[mmap_flags], fd fd, offset fileoff)
|
|
munmap(addr vma, len len[addr])
|
|
mremap(addr vma, len len[addr], newlen len[newaddr], flags flags[mremap_flags], newaddr vma)
|
|
remap_file_pages(addr vma, size len[addr], prot flags[mmap_prot], pgoff intptr, flags flags[mmap_flags])
|
|
mprotect(addr vma, len len[addr], prot flags[mmap_prot])
|
|
msync(addr vma, len len[addr], f flags[msync_flags])
|
|
madvise(addr vma, len len[addr], advice flags[madvise_flags])
|
|
fadvise64(fd fd, offset fileoff, len intptr, advice flags[fadvise_flags])
|
|
readahead(fd fd, off intptr, count intptr)
|
|
mbind(addr vma, len len[addr], mode flags[mbind_mode], nodemask ptr[in, int64], maxnode intptr, flags flags[mbind_flags])
|
|
move_pages(pid pid, nr len[pages], pages ptr[in, array[vma]], nodes ptr[in, array[int32], opt], status ptr[out, array[int32]], flags flags[move_pages_flags])
|
|
migrate_pages(pid pid, maxnode intptr, old ptr[in, int64], new ptr[in, int64])
|
|
set_mempolicy(mode flags[mbind_mode], nodemask ptr[in, int64], maxnode intptr)
|
|
get_mempolicy(mode ptr[out, int32], nodemask ptr[out, int64], maxnode intptr, addr vma, flags flags[mempolicy_flags])
|
|
mincore(addr vma, size len[addr], vec buffer[out])
|
|
mlock(addr vma, size len[addr])
|
|
mlock2(addr vma, size len[addr], flags flags[mlock_flags])
|
|
munlock(addr vma, size len[addr])
|
|
mlockall(flags flags[mlockall_flags])
|
|
munlockall()
|
|
memfd_create(name ptr[in, string], flags flags[memfd_flags]) fd
|
|
kcmp(pid1 pid, pid2 pid, type flags[kcmp_flags], fd1 fd, fd2 fd)
|
|
kcmp$KCMP_EPOLL_TFD(pid1 pid, pid2 pid, type const[KCMP_EPOLL_TFD], fd1 fd, idx2 ptr[in, kcmp_epoll_slot])
|
|
|
|
resource pkey[int32]: 0xffffffffffffffff
|
|
pkey_alloc(flags const[0], val flags[pkey_flags]) pkey
|
|
pkey_free(key pkey)
|
|
pkey_mprotect(addr vma, len len[addr], prot flags[mmap_prot], key pkey)
|
|
pkey_flags = PKEY_DISABLE_ACCESS, PKEY_DISABLE_WRITE
|
|
|
|
futex(addr ptr[in, int32[0:2]], op flags[futex_op], val int32[0:2], timeout ptr[in, timespec], addr2 ptr[in, int32[0:2]], val3 int32[0:2])
|
|
set_robust_list(head ptr[in, robust_list_head], len len[head])
|
|
get_robust_list(pid pid, head ptr[in, ptr[out, robust_list_head]], len ptr[inout, len[head, intptr]])
|
|
restart_syscall()
|
|
|
|
# Almighty!
|
|
ioctl(fd fd, cmd intptr, arg buffer[in])
|
|
|
|
ioctl$void(fd fd, cmd flags[ioctl_void])
|
|
ioctl$int_in(fd fd, cmd flags[ioctl_int_in], v ptr[in, int64])
|
|
ioctl$int_out(fd fd, cmd flags[ioctl_int_out], v ptr[out, intptr])
|
|
ioctl$fiemap(fd fd, cmd const[FS_IOC_FIEMAP], v ptr[in, fiemap])
|
|
ioctl$FS_IOC_RESVSP(fd fd, cmd const[FS_IOC_RESVSP], arg ptr[in, space_resv])
|
|
ioctl$FIBMAP(fd fd, cmd const[FIBMAP], arg ptr[in, int32])
|
|
ioctl$FICLONE(fd fd, cmd const[FICLONE], arg fd)
|
|
ioctl$FICLONERANGE(fd fd, cmd const[FICLONERANGE], arg ptr[in, file_clone_range])
|
|
ioctl$FIDEDUPERANGE(fd fd, cmd const[FIDEDUPERANGE], arg ptr[in, file_dedupe_range])
|
|
ioctl$FS_IOC_FSGETXATTR(fd fd, cmd const[FS_IOC_FSGETXATTR], arg ptr[in, fsxattr])
|
|
ioctl$FS_IOC_FSSETXATTR(fd fd, cmd const[FS_IOC_FSSETXATTR], arg ptr[in, fsxattr])
|
|
ioctl$FS_IOC_GETFSLABEL(fd fd, cmd const[FS_IOC_GETFSLABEL], arg ptr[out, array[const[0, int8], FSLABEL_MAX]])
|
|
ioctl$FS_IOC_SETFSLABEL(fd fd, cmd const[FS_IOC_SETFSLABEL], arg ptr[in, array[int8, FSLABEL_MAX]])
|
|
|
|
space_resv {
|
|
l_type const[0, int16]
|
|
l_whence flags[seek_whence, int16]
|
|
l_start int64
|
|
l_len int64
|
|
l_sysid const[0, int32]
|
|
l_pid const[0, int32]
|
|
l_pad array[const[0, int32], 4]
|
|
}
|
|
|
|
file_clone_range {
|
|
src_fd fd
|
|
pad const[0, int32]
|
|
src_offset int64
|
|
src_length int64
|
|
dest_offset int64
|
|
}
|
|
|
|
file_dedupe_range {
|
|
src_offset int64
|
|
src_length int64
|
|
dest_count len[info, int16]
|
|
reserved1 const[0, int16]
|
|
reserved2 const[0, int32]
|
|
info array[file_dedupe_range_info]
|
|
}
|
|
|
|
file_dedupe_range_info {
|
|
dest_fd fd
|
|
pad const[0, int32]
|
|
dest_offset int64
|
|
bytes_deduped const[0, int64]
|
|
status const[0, int32]
|
|
reserved const[0, int32]
|
|
}
|
|
|
|
fsxattr {
|
|
fsx_xflags int32
|
|
fsx_extsize int32
|
|
fsx_nextents int32
|
|
fsx_projid int32
|
|
fsx_cowextsize int32
|
|
fsx_pad const[0, int64]
|
|
}
|
|
|
|
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)
|
|
fcntl$getownex(fd fd, cmd const[F_GETOWN_EX], arg ptr[out, f_owner_ex])
|
|
fcntl$setownex(fd fd, cmd const[F_SETOWN_EX], arg ptr[in, f_owner_ex])
|
|
fcntl$setsig(fd fd, cmd const[F_SETSIG], sig signalno)
|
|
fcntl$setlease(fd fd, cmd const[F_SETLEASE], typ flags[flock_type])
|
|
fcntl$notify(fd fd, cmd const[F_NOTIFY], typ flags[fcntl_notify])
|
|
fcntl$setpipe(fd fd, cmd const[F_SETPIPE_SZ], sz intptr)
|
|
fcntl$addseals(fd fd, cmd const[F_ADD_SEALS], seals flags[seal_types])
|
|
fcntl$F_GET_RW_HINT(fd fd, cmd const[F_GET_RW_HINT], hint ptr[out, int64])
|
|
fcntl$F_GET_FILE_RW_HINT(fd fd, cmd const[F_GET_FILE_RW_HINT], hint ptr[out, int64])
|
|
fcntl$F_SET_RW_HINT(fd fd, cmd const[F_SET_RW_HINT], hint ptr[in, flags[fcntl_rw_hint, int64]])
|
|
fcntl$F_SET_FILE_RW_HINT(fd fd, cmd const[F_SET_FILE_RW_HINT], hint ptr[in, flags[fcntl_rw_hint, int64]])
|
|
|
|
ptrace(req flags[ptrace_req], pid pid)
|
|
ptrace$peek(req flags[ptrace_req_peek], pid pid, addr ptr[out, intptr])
|
|
ptrace$poke(req flags[ptrace_req_poke], pid pid, addr ptr[out, intptr], data intptr)
|
|
ptrace$peekuser(req const[PTRACE_PEEKUSR], pid pid, addr intptr)
|
|
ptrace$pokeuser(req const[PTRACE_POKEUSR], pid pid, addr intptr, data intptr)
|
|
ptrace$getregs(req flags[ptrace_req_getregs], pid pid, ignored intptr, data buffer[out])
|
|
ptrace$getregset(req const[PTRACE_GETREGSET], pid pid, what flags[pthread_regset], data ptr[in, iovec_out])
|
|
ptrace$setregs(req flags[ptrace_req_setregs], pid pid, ignored intptr, data buffer[in])
|
|
ptrace$setregset(req const[PTRACE_SETREGSET], pid pid, what flags[pthread_regset], data ptr[in, iovec_in])
|
|
ptrace$getsig(req const[PTRACE_GETSIGINFO], pid pid, ignored intptr, data ptr[out, siginfo])
|
|
ptrace$setsig(req const[PTRACE_SETSIGINFO], pid pid, ignored intptr, data ptr[in, siginfo])
|
|
ptrace$setopts(req flags[ptrace_req_setopts], pid pid, ignored intptr, flags flags[ptrace_options])
|
|
ptrace$getenv(req const[PTRACE_GETEVENTMSG], pid pid, ignored intptr, data ptr[out, intptr])
|
|
ptrace$cont(req flags[ptrace_req_cont], pid pid, ignored intptr, data intptr)
|
|
ptrace$PTRACE_SECCOMP_GET_FILTER(req const[PTRACE_SECCOMP_GET_FILTER], pid pid, addr intptr, data ptr[out, array[int8]])
|
|
ptrace$PTRACE_SECCOMP_GET_METADATA(req const[PTRACE_SECCOMP_GET_METADATA], pid pid, addr len[data], data ptr[in, seccomp_metadata])
|
|
|
|
seccomp_metadata {
|
|
filter_off intptr
|
|
flags const[0, int32]
|
|
}
|
|
|
|
capget(hdr ptr[in, cap_header], data ptr[in, cap_data])
|
|
capset(hdr ptr[in, cap_header], data ptr[in, cap_data])
|
|
|
|
prctl$void(option flags[prctl_code_void])
|
|
prctl$intptr(option flags[prctl_code_intptr], arg intptr)
|
|
prctl$getreaper(option flags[prctl_code_getreaper], arg ptr[out, intptr])
|
|
prctl$setendian(option const[PR_SET_ENDIAN], arg flags[prctl_endian])
|
|
prctl$setfpexc(option const[PR_SET_FPEXC], arg flags[prctl_fpexc])
|
|
prctl$setname(option const[PR_SET_NAME], name ptr[in, string])
|
|
prctl$getname(option const[PR_GET_NAME], name buffer[out])
|
|
prctl$setptracer(option const[PR_SET_PTRACER], pid pid)
|
|
prctl$seccomp(option const[PR_SET_SECCOMP], mode flags[prctl_seccomp_mode], prog ptr[in, sock_fprog])
|
|
prctl$setmm(option1 const[PR_SET_MM], option2 flags[prctl_mm_option], val vma)
|
|
|
|
arch_prctl(code flags[arch_prctl_code], addr buffer[in])
|
|
seccomp(op flags[seccomp_op], flags flags[seccomp_flags], prog ptr[in, sock_fprog])
|
|
|
|
resource fd_mq[fd]
|
|
mq_open(name ptr[in, string], flags flags[mq_open_flags], mode flags[open_mode], attr ptr[in, mq_attr]) fd_mq
|
|
mq_timedsend(mqd fd_mq, msg buffer[in], msglen len[msg], prio intptr, timeout ptr[in, timespec, opt])
|
|
mq_timedreceive(mqd fd_mq, msg buffer[out], msglen len[msg], prio intptr, timeout ptr[in, timespec, opt])
|
|
mq_notify(mqd fd_mq, notif ptr[in, sigevent])
|
|
mq_getsetattr(mqd fd_mq, attr ptr[in, mq_attr], oldattr ptr[out, mq_attr, opt])
|
|
mq_unlink(name ptr[in, string])
|
|
|
|
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])
|
|
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])
|
|
fallocate(fd fd, mode flags[fallocate_mode], off intptr, len intptr)
|
|
faccessat(dirfd fd_dir, pathname ptr[in, filename], mode flags[open_mode], flags flags[faccessat_flags])
|
|
utime(filename ptr[in, filename], times ptr[in, utimbuf])
|
|
utimes(filename ptr[in, filename], times ptr[in, itimerval])
|
|
futimesat(dir fd_dir, pathname ptr[in, filename], times ptr[in, itimerval])
|
|
utimensat(dir fd_dir, pathname ptr[in, filename], times ptr[in, itimerval], flags flags[utimensat_flags])
|
|
|
|
clone(flags flags[clone_flags], sp buffer[in], parentid ptr[out, int32], childtid ptr[out, int32], tls buffer[in])
|
|
|
|
resource pid[int32]: 0, 0xffffffffffffffff
|
|
resource uid[int32]: 0, 0xffffffffffffffff
|
|
resource gid[int32]: 0, 0xffffffffffffffff
|
|
|
|
getgid() gid
|
|
getegid() gid
|
|
setuid(uid uid)
|
|
setgid(gid gid)
|
|
getuid() uid
|
|
geteuid() uid
|
|
setpgid(pid pid, pgid pid)
|
|
getpgid(pid pid) pid
|
|
getpgrp(pid pid) pid
|
|
getpid() pid
|
|
gettid() pid
|
|
setreuid(ruid uid, euid uid)
|
|
setregid(rgid gid, egid gid)
|
|
setresuid(ruid uid, euid uid, suid uid)
|
|
setresgid(rgid gid, egid gid, sgid gid)
|
|
getresuid(ruid ptr[out, uid], euid ptr[out, uid], suid ptr[out, uid])
|
|
getresgid(rgid ptr[out, gid], egid ptr[out, gid], sgid ptr[out, gid])
|
|
setfsuid(fsuid uid)
|
|
setfsgid(fsgid gid)
|
|
getgroups(size len[list], list ptr[inout, array[gid]])
|
|
setgroups(size len[list], list ptr[in, array[gid]])
|
|
personality(persona flags[personality_flags])
|
|
# Don't mess with parent (fuzzer). If we ptrace attach to it, it will hang.
|
|
# If we setrlimit for parent, it will misbehave. Killing - the same. Nothing good.
|
|
#getppid() pid
|
|
#getsid(pid pid) pid
|
|
#setsid() pid
|
|
|
|
resource fd_inotify[fd]
|
|
resource fd_fanotify[fd]
|
|
resource inotifydesc[int32]
|
|
inotify_init() fd_inotify
|
|
inotify_init1(flags flags[inotify_flags]) fd_inotify
|
|
inotify_add_watch(fd fd_inotify, file ptr[in, filename], mask flags[inotify_mask]) inotifydesc
|
|
inotify_rm_watch(fd fd_inotify, wd inotifydesc)
|
|
fanotify_init(flags flags[fanotify_flags], events flags[fanotify_events]) fd_fanotify
|
|
fanotify_mark(fd fd_fanotify, flags flags[fanotify_mark], mask flags[fanotify_mask], fddir fd_dir, path ptr[in, filename])
|
|
ioctl$INOTIFY_IOC_SETNEXTWD(fd fd_inotify, cmd const[INOTIFY_IOC_SETNEXTWD], arg intptr)
|
|
|
|
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])
|
|
renameat2(oldfd fd_dir, old ptr[in, filename], newfd fd_dir, new ptr[in, filename], flags flags[renameat2_flags])
|
|
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()
|
|
syncfs(fd fd)
|
|
sync_file_range(fd fd, off intptr, nbytes intptr, flags flags[sync_file_flags])
|
|
lookup_dcookie(cookie int64, buf buffer[out], len len[buf])
|
|
getdents(fd fd_dir, ent buffer[out], count len[ent])
|
|
getdents64(fd fd_dir, ent buffer[out], count len[ent])
|
|
name_to_handle_at(fd fd_dir, file ptr[in, filename], handle ptr[in, file_handle], mnt ptr[out, int32], flags flags[name_to_handle_at_flags])
|
|
open_by_handle_at(mountdirfd fd, handle ptr[in, file_handle], flags flags[open_flags])
|
|
chroot(dir ptr[in, filename])
|
|
getcwd(buf buffer[out], size len[buf])
|
|
chdir(dir ptr[in, filename])
|
|
fchdir(fd fd)
|
|
quotactl(cmd intptr, special ptr[in, filename], id uid, addr ptr[in, array[int8]])
|
|
pivot_root(new_root ptr[in, filename], put_old ptr[in, filename])
|
|
|
|
sysfs$1(option const[1], fsname ptr[in, string])
|
|
sysfs$2(option const[2], fsindex intptr, fsname buffer[out])
|
|
sysfs$3(option const[3])
|
|
statfs(path ptr[in, filename], buf buffer[out])
|
|
fstatfs(fd fd, buf buffer[out])
|
|
|
|
uselib(lib ptr[in, filename])
|
|
init_module(mod ptr[in, string], len len[mod], args ptr[in, string])
|
|
finit_module(fd fd, args ptr[in, string], flags flags[finit_module_flags])
|
|
delete_module(name ptr[in, string], flags flags[delete_module_flags])
|
|
kexec_load(entry intptr, nr_segments len[segments], segments ptr[in, array[kexec_segment]], flags flags[kexec_load_flags])
|
|
syslog(cmd flags[syslog_cmd], buf buffer[out, opt], len len[buf])
|
|
uname(buf buffer[out])
|
|
sysinfo(info buffer[out])
|
|
ustat(dev intptr, buf ptr[out, ustat])
|
|
acct(filename ptr[in, filename, opt])
|
|
|
|
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])
|
|
prlimit64(pid pid, res flags[rlimit_type], new ptr[in, rlimit, opt], old ptr[out, rlimit, opt])
|
|
|
|
iopl(level int8)
|
|
ioperm(from intptr, num intptr, on intptr)
|
|
ioprio_get$pid(which flags[ioprio_which_pid], who pid)
|
|
ioprio_get$uid(which flags[ioprio_which_uid], who uid)
|
|
ioprio_set$pid(which flags[ioprio_which_pid], who pid, prio intptr)
|
|
ioprio_set$uid(which flags[ioprio_which_uid], who uid, prio intptr)
|
|
|
|
resource timerid[int32]
|
|
timer_create(id flags[clock_id], ev ptr[in, sigevent], timerid ptr[out, timerid])
|
|
timer_gettime(timerid timerid, setting ptr[out, itimerspec])
|
|
timer_getoverrun(timerid timerid)
|
|
timer_settime(timerid timerid, flags flags[timer_flags], new ptr[in, itimerspec], old ptr[out, itimerspec, opt])
|
|
timer_delete(timerid timerid)
|
|
|
|
time(t ptr[out, intptr])
|
|
clock_gettime(id flags[clock_id], tp ptr[out, timespec])
|
|
clock_settime(id flags[clock_id], tp ptr[in, timespec])
|
|
clock_adjtime(id flags[clock_id], tx ptr[in, timex])
|
|
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])
|
|
rt_sigaction(sig signalno, act ptr[in, sigaction], oact ptr[out, sigaction, opt], sigsetsize len[fake], fake ptr[out, sigset])
|
|
rt_sigprocmask(how flags[sigprocmask_how], nset ptr[in, sigset], oset ptr[out, sigset, opt], sigsetsize len[nset])
|
|
rt_sigreturn()
|
|
rt_sigpending(set ptr[out, sigset], sigsetsize len[set])
|
|
rt_sigtimedwait(these ptr[in, sigset], info ptr[out, siginfo, opt], ts ptr[in, timespec], sigsetsize len[these])
|
|
rt_sigsuspend(new ptr[in, sigset], sigsetsize len[new])
|
|
rt_sigqueueinfo(pid pid, sig signalno, info ptr[in, siginfo])
|
|
rt_tgsigqueueinfo(gid pid, tid pid, sig signalno, info ptr[in, siginfo])
|
|
sigaltstack(ss vma, oss ptr[out, intptr, opt])
|
|
tgkill(gid pid, tid pid, sig signalno)
|
|
tkill(tid pid, sig signalno)
|
|
pause()
|
|
alarm(seconds intptr)
|
|
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])
|
|
exit(code intptr)
|
|
exit_group(code intptr)
|
|
waitid(which flags[waitid_which], pid pid, infop ptr[out, siginfo, opt], options flags[wait_options], ru ptr[out, rusage, opt])
|
|
wait4(pid pid, status ptr[out, int32, opt], options flags[wait_options], ru ptr[out, rusage, opt])
|
|
times(buf ptr[out, tms])
|
|
# Can send signals to all processes (pid=-1).
|
|
#kill(pid pid, sig signalno)
|
|
|
|
set_thread_area(info ptr[in, user_desc])
|
|
get_thread_area(info ptr[in, user_desc])
|
|
modify_ldt$read(func const[0], buf buffer[out], len len[buf])
|
|
modify_ldt$write(func const[1], buf ptr[in, user_desc], len len[buf])
|
|
modify_ldt$read_default(func const[2], buf buffer[out], len len[buf])
|
|
modify_ldt$write2(func const[17], buf ptr[in, user_desc], len len[buf])
|
|
process_vm_readv(pid pid, loc_vec ptr[in, array[iovec_out]], loc_vlen len[loc_vec], rem_vec ptr[in, array[iovec_out]], rem_vlen len[rem_vec], flags const[0])
|
|
process_vm_writev(pid pid, loc_vec ptr[in, array[iovec_out]], loc_vlen len[loc_vec], rem_vec ptr[in, array[iovec_out]], rem_vlen len[rem_vec], flags const[0])
|
|
set_tid_address(tidptr ptr[out, int32])
|
|
getpriority(which flags[priority_which], who pid)
|
|
setpriority(which flags[priority_which], who pid, prio intptr)
|
|
sched_getscheduler(pid pid)
|
|
sched_setscheduler(pid pid, policy flags[sched_policy], prio ptr[in, int32])
|
|
sched_rr_get_interval(pid pid, tp ptr[out, timespec])
|
|
sched_getparam(pid pid, prio ptr[out, int32])
|
|
sched_setparam(pid pid, prio ptr[in, int32])
|
|
sched_getaffinity(pid pid, cpusetsize len[mask], mask ptr[out, int64])
|
|
sched_setaffinity(pid pid, cpusetsize len[mask], mask ptr[in, int64])
|
|
sched_getattr(pid pid, attr ptr[out, sched_attr], size len[attr], flags flags[sched_attr_flags])
|
|
sched_setattr(pid pid, attr ptr[in, sched_attr], flags flags[sched_attr_flags])
|
|
sched_yield()
|
|
getrandom(buf buffer[out], len len[buf], flags flags[getrandom_flags])
|
|
|
|
membarrier(cmd flags[membarrier_cmd], flags const[0])
|
|
|
|
membarrier_cmd = MEMBARRIER_CMD_GLOBAL, MEMBARRIER_CMD_GLOBAL_EXPEDITED, MEMBARRIER_CMD_PRIVATE_EXPEDITED, MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED, MEMBARRIER_CMD_PRIVATE_EXPEDITED_SYNC_CORE, MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_SYNC_CORE
|
|
|
|
rseq(rseq ptr[in, rseq], rseq_len bytesize[rseq], flags boolptr, sig const[0])
|
|
|
|
rseq {
|
|
cpu_id_start const[0, int32]
|
|
cpu_id const[0, int32]
|
|
rseq_cs ptr[in, rseq_cs, opt]
|
|
flags flags[rseq_cs_flags, int32]
|
|
} [align_32]
|
|
|
|
rseq_cs {
|
|
version const[0, int32]
|
|
flags flags[rseq_cs_flags, int32]
|
|
start_ip intptr
|
|
post_commit_offset intptr
|
|
abort_ip intptr
|
|
} [align_32]
|
|
|
|
rseq_cs_flags = RSEQ_CS_FLAG_NO_RESTART_ON_PREEMPT, RSEQ_CS_FLAG_NO_RESTART_ON_SIGNAL, RSEQ_CS_FLAG_NO_RESTART_ON_MIGRATE
|
|
|
|
syz_open_procfs(pid pid, file ptr[in, string[procfs_file]]) fd
|
|
|
|
procfs_file = "auxv", "cmdline", "environ", "autogroup", "cgroup", "clear_refs", "comm", "coredump_filter", "cpuset", "gid_map", "io", "limits", "loginuid", "maps", "mountinfo", "mounts", "mountstats", "numa_maps", "oom_adj", "oom_score", "oom_score_adj", "pagemap", "personality", "projid_map", "sched", "schedstat", "sessionid", "setgroups", "smaps", "smaps_rollup", "stack", "stat", "statm", "status", "syscall", "timers", "uid_map", "wchan", "map_files", "attr", "attr/current", "attr/exec", "attr/fscreate", "attr/keycreate", "attr/prev", "attr/sockcreate", "ns", "children", "task", "fd", "fd/3", "fd/4", "fdinfo", "fdinfo/3", "fdinfo/4", "net", "net/anycast6", "net/arp", "net/bnep", "net/connector", "net/dev", "net/dev_mcast", "net/dev_snmp6", "net/fib_trie", "net/fib_triestat", "net/hci", "net/icmp", "net/icmp6", "net/if_inet6", "net/igmp", "net/igmp6", "net/ip6_flowlabel", "net/ip6_mr_cache", "net/ip6_mr_vif", "net/ip6_tables_matches", "net/ip6_tables_names", "net/ip6_tables_targets", "net/ip_mr_cache", "net/ip_mr_vif", "net/ip_tables_matches", "net/ip_tables_names", "net/ip_tables_targets", "net/ipv6_route", "net/ipx", "net/l2cap", "net/llc", "net/mcfilter", "net/mcfilter6", "net/netfilter", "net/netlink", "net/netstat", "net/nfsfs", "net/packet", "net/protocols", "net/psched", "net/ptype", "net/raw", "net/raw6", "net/rfcomm", "net/route", "net/rpc", "net/rt6_stats", "net/rt_acct", "net/rt_cache", "net/sco", "net/sctp", "net/snmp", "net/snmp6", "net/sockstat", "net/sockstat6", "net/softnet_stat", "net/stat", "net/tcp", "net/tcp6", "net/udp", "net/udp6", "net/udplite", "net/udplite6", "net/unix", "net/wireless", "net/xfrm_stat", "net/ip_vs", "net/ip_vs_stats", "net/ip_vs_stats_percpu"
|
|
|
|
# Uncomment on your own account.
|
|
#syz_open_dev$char(dev const[0xc], major intptr, minor intptr) fd
|
|
#syz_open_dev$block(dev const[0xb], major intptr, minor intptr) fd
|
|
|
|
# /dev/console known to cause problems on at least two different kernels.
|
|
# It can turn off all output or produce massive amounts of garbage on console.
|
|
# Disable it for now.
|
|
#syz_open_dev$console(dev ptr[in, string["/dev/console"]], id const[0], flags flags[open_flags]) fd
|
|
|
|
# These devices are relatively safe (don't reboot and don't corrupt kernel memory).
|
|
# They need a more comprehensive support. But let at least open them for now,
|
|
# maybe fuzzer will be able to skrew them in a useful way.
|
|
syz_open_dev$floppy(dev ptr[in, string["/dev/fd#"]], id intptr, flags flags[open_flags]) fd
|
|
syz_open_dev$vcsn(dev ptr[in, string["/dev/vcs#"]], id intptr, flags flags[open_flags]) fd
|
|
syz_open_dev$vcsa(dev ptr[in, string["/dev/vcsa#"]], id intptr, flags flags[open_flags]) fd
|
|
syz_open_dev$usbmon(dev ptr[in, string["/dev/usbmon#"]], id intptr, flags flags[open_flags]) fd
|
|
syz_open_dev$midi(dev ptr[in, string["/dev/midi#"]], id intptr, flags flags[open_flags]) fd
|
|
syz_open_dev$ircomm(dev ptr[in, string["/dev/ircomm#"]], id intptr, flags flags[open_flags]) fd
|
|
syz_open_dev$dspn(dev ptr[in, string["/dev/dsp#"]], id intptr, flags flags[open_flags]) fd
|
|
syz_open_dev$dmmidi(dev ptr[in, string["/dev/dmmidi#"]], id intptr, flags flags[open_flags]) fd
|
|
syz_open_dev$admmidi(dev ptr[in, string["/dev/admmidi#"]], id intptr, flags flags[open_flags]) fd
|
|
syz_open_dev$adsp(dev ptr[in, string["/dev/adsp#"]], id intptr, flags flags[open_flags]) fd
|
|
syz_open_dev$amidi(dev ptr[in, string["/dev/amidi#"]], id intptr, flags flags[open_flags]) fd
|
|
syz_open_dev$audion(dev ptr[in, string["/dev/audio#"]], id intptr, flags flags[open_flags]) fd
|
|
syz_open_dev$usb(dev ptr[in, string["/dev/bus/usb/00#/00#"]], id intptr, flags flags[open_flags]) fd
|
|
syz_open_dev$sndhw(dev ptr[in, string["/dev/snd/hwC#D#"]], id intptr, flags flags[open_flags]) fd
|
|
syz_open_dev$sndpcmc(dev ptr[in, string["/dev/snd/pcmC#D#c"]], id intptr, flags flags[open_flags]) fd
|
|
syz_open_dev$sndpcmp(dev ptr[in, string["/dev/snd/pcmC#D#p"]], id intptr, flags flags[open_flags]) fd
|
|
|
|
openat$null(fd const[AT_FDCWD], file ptr[in, string["/dev/null"]], flags flags[open_flags], mode const[0]) fd
|
|
openat$zero(fd const[AT_FDCWD], file ptr[in, string["/dev/zero"]], flags flags[open_flags], mode const[0]) fd
|
|
openat$full(fd const[AT_FDCWD], file ptr[in, string["/dev/full"]], flags flags[open_flags], mode const[0]) fd
|
|
openat$snapshot(fd const[AT_FDCWD], file ptr[in, string["/dev/snapshot"]], flags flags[open_flags], mode const[0]) fd
|
|
openat$uinput(fd const[AT_FDCWD], file ptr[in, string["/dev/uinput"]], flags flags[open_flags], mode const[0]) fd
|
|
openat$urandom(fd const[AT_FDCWD], file ptr[in, string["/dev/urandom"]], flags flags[open_flags], mode const[0]) fd
|
|
openat$vga_arbiter(fd const[AT_FDCWD], file ptr[in, string["/dev/vga_arbiter"]], flags flags[open_flags], mode const[0]) fd
|
|
openat$vhci(fd const[AT_FDCWD], file ptr[in, string["/dev/vhci"]], flags flags[open_flags], mode const[0]) fd
|
|
openat$userio(fd const[AT_FDCWD], file ptr[in, string["/dev/userio"]], flags flags[open_flags], mode const[0]) fd
|
|
openat$rtc(fd const[AT_FDCWD], file ptr[in, string["/dev/rtc0"]], flags flags[open_flags], mode const[0]) fd
|
|
openat$rfkill(fd const[AT_FDCWD], file ptr[in, string["/dev/rfkill"]], flags flags[open_flags], mode const[0]) fd
|
|
openat$qat_adf_ctl(fd const[AT_FDCWD], file ptr[in, string["/dev/qat_adf_ctl"]], flags flags[open_flags], mode const[0]) fd
|
|
openat$ppp(fd const[AT_FDCWD], file ptr[in, string["/dev/ppp"]], flags flags[open_flags], mode const[0]) fd
|
|
openat$mixer(fd const[AT_FDCWD], file ptr[in, string["/dev/mixer"]], flags flags[open_flags], mode const[0]) fd
|
|
openat$irnet(fd const[AT_FDCWD], file ptr[in, string["/dev/irnet"]], flags flags[open_flags], mode const[0]) fd
|
|
openat$hwrng(fd const[AT_FDCWD], file ptr[in, string["/dev/hwrng"]], flags flags[open_flags], mode const[0]) fd
|
|
openat$hpet(fd const[AT_FDCWD], file ptr[in, string["/dev/hpet"]], flags flags[open_flags], mode const[0]) fd
|
|
openat$hidraw0(fd const[AT_FDCWD], file ptr[in, string["/dev/hidraw0"]], flags flags[open_flags], mode const[0]) fd
|
|
openat$fb0(fd const[AT_FDCWD], file ptr[in, string["/dev/fb0"]], flags flags[open_flags], mode const[0]) fd
|
|
openat$cuse(fd const[AT_FDCWD], file ptr[in, string["/dev/cuse"]], flags flags[open_flags], mode const[0]) fd
|
|
openat$capi20(fd const[AT_FDCWD], file ptr[in, string["/dev/capi20"]], flags flags[open_flags], mode const[0]) fd
|
|
openat$autofs(fd const[AT_FDCWD], file ptr[in, string["/dev/autofs"]], flags flags[open_flags], mode const[0]) fd
|
|
openat$keychord(fd const[AT_FDCWD], file ptr[in, string["/dev/keychord"]], flags flags[open_flags], mode const[0]) fd
|
|
openat$zygote(fd const[AT_FDCWD], file ptr[in, string["/dev/socket/zygote"]], flags flags[open_flags], mode const[0]) fd
|
|
openat$sw_sync(fd const[AT_FDCWD], file ptr[in, string["/dev/sw_sync"]], flags flags[open_flags], mode const[0]) fd
|
|
openat$pktcdvd(fd const[AT_FDCWD], file ptr[in, string["/dev/pktcdvd/control"]], flags flags[open_flags], mode const[0]) fd
|
|
openat$lightnvm(fd const[AT_FDCWD], file ptr[in, string["/dev/lightnvm/control"]], flags flags[open_flags], mode const[0]) fd
|
|
openat$vcs(fd const[AT_FDCWD], file ptr[in, string["/dev/vcs"]], flags flags[open_flags], mode const[0]) fd
|
|
openat$sequencer(fd const[AT_FDCWD], file ptr[in, string["/dev/sequencer"]], flags flags[open_flags], mode const[0]) fd
|
|
openat$sequencer2(fd const[AT_FDCWD], file ptr[in, string["/dev/sequencer2"]], flags flags[open_flags], mode const[0]) fd
|
|
openat$dsp(fd const[AT_FDCWD], file ptr[in, string["/dev/dsp"]], flags flags[open_flags], mode const[0]) fd
|
|
openat$audio(fd const[AT_FDCWD], file ptr[in, string["/dev/audio"]], flags flags[open_flags], mode const[0]) fd
|
|
openat$xenevtchn(fd const[AT_FDCWD], file ptr[in, string["/dev/xen/evtchn"]], flags flags[open_flags], mode const[0]) fd
|
|
|
|
pipefd {
|
|
rfd fd
|
|
wfd fd
|
|
}
|
|
|
|
type iovec[DIR, T] {
|
|
addr ptr[DIR, T]
|
|
len len[addr, intptr]
|
|
}
|
|
type iovec_in iovec[in, array[int8]]
|
|
type iovec_out iovec[out, array[int8]]
|
|
|
|
stat {
|
|
dev int16
|
|
ino int32
|
|
mode int16
|
|
nlink int16
|
|
uid uid
|
|
gid gid
|
|
rdev int16
|
|
size int32
|
|
blksize int32
|
|
blocks int32
|
|
atime int32
|
|
ansec int32
|
|
mtime int32
|
|
mnsec int32
|
|
ctime int32
|
|
cnsec int32
|
|
pad1 int32
|
|
pad2 int32
|
|
}
|
|
|
|
statx {
|
|
mask int32
|
|
blksize int32
|
|
attributes int64
|
|
nlink int32
|
|
uid int32
|
|
gid int32
|
|
mode int16
|
|
__spare0 int16
|
|
ino int64
|
|
size int64
|
|
blocks int64
|
|
__spare1 int64
|
|
atime statx_timestamp
|
|
btime statx_timestamp
|
|
ctime statx_timestamp
|
|
mtime statx_timestamp
|
|
rdev_major int32
|
|
rdev_minor int32
|
|
dev_major int32
|
|
dev_minor int32
|
|
__spare2 array[int64, 14]
|
|
}
|
|
|
|
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 time_sec
|
|
nsec time_nsec
|
|
}
|
|
|
|
# prog knowns about this struct type
|
|
timeval {
|
|
sec time_sec
|
|
usec time_usec
|
|
}
|
|
|
|
statx_timestamp {
|
|
sec int64
|
|
nsec int32
|
|
__reserved int32
|
|
}
|
|
|
|
itimerspec {
|
|
interv timespec
|
|
value timespec
|
|
}
|
|
|
|
itimerval {
|
|
interv timeval
|
|
value timeval
|
|
}
|
|
|
|
utimbuf {
|
|
actime intptr
|
|
modtime intptr
|
|
}
|
|
|
|
sigevent {
|
|
val const[0, intptr]
|
|
signo signalno
|
|
notify flags[sigev_notify, int32]
|
|
u sigevent_u
|
|
} [size[SIGEVENT_SIZE]]
|
|
|
|
sigevent_u [
|
|
tid pid
|
|
thr sigevent_thread
|
|
]
|
|
|
|
define SIGEVENT_SIZE sizeof(struct sigevent)
|
|
|
|
sigevent_thread {
|
|
# TODO: this is function pointer and pthread_attr_t (?)
|
|
func buffer[in]
|
|
attr buffer[in]
|
|
}
|
|
|
|
cap_header {
|
|
var flags[cap_version, int32]
|
|
pid pid
|
|
}
|
|
|
|
cap_data {
|
|
eff0 int32
|
|
perm0 int32
|
|
inher0 int32
|
|
eff1 int32
|
|
perm1 int32
|
|
inher1 int32
|
|
}
|
|
|
|
epoll_event {
|
|
ev flags[epoll_ev, int32]
|
|
data const[0, int64]
|
|
} [packed]
|
|
|
|
# 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_head {
|
|
list ptr[in, robust_list, opt]
|
|
futex_offset intptr
|
|
list_op_pending ptr[in, robust_list, opt]
|
|
}
|
|
|
|
robust_list {
|
|
next ptr[in, robust_list, opt]
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
sigaction {
|
|
# TODO: function pointers need special support
|
|
handler intptr
|
|
mask sigset
|
|
flags flags[sigaction_flags, intptr]
|
|
restor intptr
|
|
}
|
|
|
|
tms {
|
|
utime intptr
|
|
stime intptr
|
|
cutime intptr
|
|
cstime intptr
|
|
}
|
|
|
|
siginfo {
|
|
signo signalno
|
|
errno int32
|
|
code int32
|
|
pad3 int32
|
|
# actual size is 128 bytes
|
|
}
|
|
|
|
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
|
|
|
|
sched_attr {
|
|
size flags[sched_attr_size, int32]
|
|
policy flags[sched_policy, int32]
|
|
flags flags[sched_attr_flags2, int64]
|
|
nice int32
|
|
prio int32
|
|
runtime int64
|
|
deadlin int64
|
|
period int64
|
|
}
|
|
|
|
flock {
|
|
type flags[flock_type, int16]
|
|
whence flags[seek_whence, int16]
|
|
start intptr
|
|
len intptr
|
|
pid pid
|
|
}
|
|
|
|
f_owner_ex {
|
|
type flags[f_owner_type, int32]
|
|
pid pid
|
|
}
|
|
|
|
ucred {
|
|
pid pid
|
|
uid uid
|
|
gid gid
|
|
}
|
|
|
|
fiemap {
|
|
start int64
|
|
len int64
|
|
flags flags[fiemap_flags, int32]
|
|
mapped int32
|
|
count len[extent, int32]
|
|
extent array[fiemap_extent]
|
|
}
|
|
|
|
fiemap_extent {
|
|
logical int64
|
|
phys int64
|
|
len int64
|
|
pad1 const[0, int64]
|
|
pad2 const[0, int64]
|
|
flags flags[fiemap_extent_flags, int32]
|
|
pad3 const[0, int32]
|
|
pad4 const[0, int32]
|
|
pad5 const[0, int32]
|
|
}
|
|
|
|
kcmp_epoll_slot {
|
|
efd fd_epoll
|
|
tfd fd
|
|
toff int32
|
|
}
|
|
|
|
open_flags = O_RDONLY, O_WRONLY, O_RDWR, O_APPEND, FASYNC, O_CLOEXEC, O_CREAT, O_DIRECT, O_DIRECTORY, O_EXCL, O_LARGEFILE, O_NOATIME, O_NOCTTY, O_NOFOLLOW, O_NONBLOCK, O_PATH, O_SYNC, O_TRUNC, __O_TMPFILE
|
|
open_mode = S_IRUSR, S_IWUSR, S_IXUSR, S_IRGRP, S_IWGRP, S_IXGRP, S_IROTH, S_IWOTH, S_IXOTH
|
|
madvise_flags = MADV_NORMAL, MADV_RANDOM, MADV_SEQUENTIAL, MADV_WILLNEED, MADV_DONTNEED, MADV_REMOVE, MADV_DONTFORK, MADV_DOFORK, MADV_HWPOISON, MADV_SOFT_OFFLINE, MADV_MERGEABLE, MADV_UNMERGEABLE, MADV_HUGEPAGE, MADV_NOHUGEPAGE, MADV_DONTDUMP, MADV_DODUMP, MADV_WIPEONFORK, MADV_KEEPONFORK
|
|
fadvise_flags = POSIX_FADV_NORMAL, POSIX_FADV_SEQUENTIAL, POSIX_FADV_RANDOM, POSIX_FADV_NOREUSE, POSIX_FADV_WILLNEED, POSIX_FADV_DONTNEED
|
|
move_pages_flags = MPOL_MF_MOVE, MPOL_MF_MOVE_ALL
|
|
msync_flags = MS_ASYNC, MS_SYNC, MS_INVALIDATE
|
|
mmap_prot = PROT_NONE, PROT_EXEC, PROT_READ, PROT_WRITE, PROT_SEM, PROT_GROWSDOWN, PROT_GROWSUP
|
|
mmap_flags = MAP_SHARED, MAP_PRIVATE, MAP_32BIT, MAP_ANONYMOUS, MAP_DENYWRITE, MAP_EXECUTABLE, MAP_FILE, MAP_FIXED, MAP_GROWSDOWN, MAP_HUGETLB, MAP_LOCKED, MAP_NONBLOCK, MAP_NORESERVE, MAP_POPULATE, MAP_STACK, MAP_UNINITIALIZED, MAP_SHARED_VALIDATE, MAP_SYNC, MAP_FIXED_NOREPLACE
|
|
mremap_flags = MREMAP_MAYMOVE, MREMAP_FIXED
|
|
mbind_mode = MPOL_DEFAULT, MPOL_BIND, MPOL_INTERLEAVE, MPOL_PREFERRED, MPOL_F_STATIC_NODES, MPOL_F_RELATIVE_NODES
|
|
mbind_flags = MPOL_MF_STRICT, MPOL_MF_MOVE, MPOL_MF_MOVE_ALL
|
|
memfd_flags = MFD_CLOEXEC, MFD_ALLOW_SEALING
|
|
pipe_flags = O_NONBLOCK, O_CLOEXEC, O_DIRECT
|
|
mlock_flags = MLOCK_ONFAULT
|
|
mlockall_flags = MCL_CURRENT, MCL_FUTURE
|
|
dup_flags = O_CLOEXEC
|
|
splice_flags = SPLICE_F_MOVE, SPLICE_F_NONBLOCK, SPLICE_F_MORE, SPLICE_F_GIFT
|
|
seek_whence = SEEK_SET, SEEK_CUR, SEEK_END, SEEK_DATA, SEEK_HOLE
|
|
signalfd_flags = SFD_NONBLOCK, SFD_CLOEXEC
|
|
eventfd_flags = EFD_CLOEXEC, EFD_NONBLOCK, EFD_SEMAPHORE
|
|
timerfd_create_flags = TFD_NONBLOCK, TFD_CLOEXEC
|
|
timerfd_settime_flags = TFD_TIMER_ABSTIME
|
|
clock_type = CLOCK_REALTIME, CLOCK_REALTIME_COARSE, CLOCK_MONOTONIC, CLOCK_MONOTONIC_COARSE, CLOCK_MONOTONIC_RAW, CLOCK_BOOTTIME, CLOCK_PROCESS_CPUTIME_ID, CLOCK_THREAD_CPUTIME_ID
|
|
sigev_notify = SIGEV_NONE, SIGEV_SIGNAL, SIGEV_THREAD, SIGEV_THREAD_ID
|
|
cap_version = 0x19980330, 0x20071026, 0x20080522
|
|
prctl_code_void = PR_GET_DUMPABLE, PR_GET_KEEPCAPS, PR_GET_NO_NEW_PRIVS, PR_GET_SECCOMP, PR_GET_SECUREBITS, PR_GET_TIMERSLACK, PR_GET_TIMING, PR_TASK_PERF_EVENTS_DISABLE, PR_TASK_PERF_EVENTS_ENABLE, PR_MCE_KILL_GET
|
|
prctl_code_intptr = PR_CAPBSET_READ, PR_CAPBSET_DROP, PR_SET_CHILD_SUBREAPER, PR_SET_DUMPABLE, PR_SET_FPEMU, PR_SET_KEEPCAPS, PR_SET_NO_NEW_PRIVS, PR_SET_PDEATHSIG, PR_SET_SECUREBITS, PR_SET_TIMERSLACK, PR_SET_TIMING, PR_SET_TSC, PR_SET_UNALIGN, PR_MCE_KILL
|
|
prctl_code_getreaper = PR_GET_CHILD_SUBREAPER, PR_GET_ENDIAN, PR_GET_FPEMU, PR_GET_FPEXC, PR_GET_PDEATHSIG, PR_GET_TID_ADDRESS, PR_GET_TSC, PR_GET_UNALIGN
|
|
prctl_endian = PR_ENDIAN_BIG, PR_ENDIAN_LITTLE, PR_ENDIAN_PPC_LITTLE
|
|
prctl_fpexc = PR_FP_EXC_SW_ENABLE, PR_FP_EXC_DIV, PR_FP_EXC_OVF, PR_FP_EXC_UND, PR_FP_EXC_RES, PR_FP_EXC_INV, PR_FP_EXC_DISABLED, PR_FP_EXC_NONRECOV, PR_FP_EXC_ASYNC, PR_FP_EXC_PRECISE
|
|
prctl_seccomp_mode = SECCOMP_MODE_DISABLED, SECCOMP_MODE_STRICT, SECCOMP_MODE_FILTER
|
|
prctl_mm_option = PR_SET_MM_START_CODE, PR_SET_MM_END_CODE, PR_SET_MM_START_DATA, PR_SET_MM_END_DATA, PR_SET_MM_START_STACK, PR_SET_MM_START_BRK, PR_SET_MM_BRK
|
|
arch_prctl_code = ARCH_SET_FS, ARCH_GET_FS, ARCH_SET_GS, ARCH_GET_GS
|
|
epoll_flags = EPOLL_CLOEXEC
|
|
epoll_op = EPOLL_CTL_ADD, EPOLL_CTL_MOD, EPOLL_CTL_DEL
|
|
epoll_ev = POLLIN, POLLOUT, POLLRDHUP, POLLPRI, POLLERR, POLLHUP, EPOLLET, EPOLLONESHOT, EPOLLEXCLUSIVE, EPOLLWAKEUP
|
|
pollfd_events = POLLIN, POLLPRI, POLLOUT, POLLERR, POLLHUP, POLLNVAL, POLLRDNORM, POLLRDBAND, POLLWRNORM, POLLWRBAND, POLLMSG, POLLREMOVE, POLLRDHUP, POLLFREE, POLL_BUSY_LOOP
|
|
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_EMPTY_PATH, AT_SYMLINK_NOFOLLOW, AT_SYMLINK_FOLLOW, AT_NO_AUTOMOUNT, AT_EMPTY_PATH
|
|
fallocate_mode = 0, FALLOC_FL_KEEP_SIZE, FALLOC_FL_PUNCH_HOLE, FALLOC_FL_COLLAPSE_RANGE, FALLOC_FL_ZERO_RANGE, FALLOC_FL_INSERT_RANGE, FALLOC_FL_UNSHARE_RANGE
|
|
linkat_flags = AT_EMPTY_PATH, AT_SYMLINK_FOLLOW
|
|
unlinkat_flags = 0, AT_REMOVEDIR
|
|
renameat2_flags = RENAME_EXCHANGE, RENAME_NOREPLACE, RENAME_WHITEOUT
|
|
flock_op = LOCK_SH, LOCK_EX, LOCK_UN, LOCK_NB
|
|
seccomp_op = SECCOMP_SET_MODE_STRICT, SECCOMP_SET_MODE_FILTER
|
|
seccomp_flags = 0, SECCOMP_FILTER_FLAG_TSYNC
|
|
statx_flags = AT_SYMLINK_NOFOLLOW, AT_SYMLINK_FOLLOW, AT_NO_AUTOMOUNT, AT_EMPTY_PATH, AT_STATX_SYNC_TYPE, AT_STATX_SYNC_AS_STAT, AT_STATX_FORCE_SYNC, AT_STATX_DONT_SYNC
|
|
statx_mask = STATX_TYPE, STATX_MODE, STATX_NLINK, STATX_UID, STATX_GID, STATX_ATIME, STATX_MTIME, STATX_CTIME, STATX_INO, STATX_SIZE, STATX_BLOCKS, STATX_BASIC_STATS, STATX_BTIME, STATX_ALL
|
|
name_to_handle_at_flags = AT_EMPTY_PATH, AT_SYMLINK_FOLLOW
|
|
mq_open_flags = O_RDONLY, O_WRONLY, O_RDWR, O_NONBLOCK, O_CREAT, O_EXCL, O_CREAT
|
|
finit_module_flags = MODULE_INIT_IGNORE_MODVERSIONS, MODULE_INIT_IGNORE_VERMAGIC
|
|
delete_module_flags = O_NONBLOCK, O_TRUNC
|
|
kexec_load_flags = KEXEC_ON_CRASH, KEXEC_PRESERVE_CONTEXT, KEXEC_ARCH_386, KEXEC_ARCH_X86_64, KEXEC_ARCH_PPC, KEXEC_ARCH_PPC64, KEXEC_ARCH_IA_64, KEXEC_ARCH_ARM, KEXEC_ARCH_S390, KEXEC_ARCH_SH, KEXEC_ARCH_MIPS, KEXEC_ARCH_MIPS_LE
|
|
inotify_flags = IN_NONBLOCK, IN_CLOEXEC
|
|
inotify_mask = IN_ACCESS, IN_ATTRIB, IN_CLOSE_WRITE, IN_CLOSE_NOWRITE, IN_CREATE, IN_DELETE, IN_DELETE_SELF, IN_MODIFY, IN_MOVE_SELF, IN_MOVED_FROM, IN_MOVED_TO, IN_OPEN, IN_DONT_FOLLOW, IN_EXCL_UNLINK, IN_MASK_ADD, IN_ONESHOT, IN_ONLYDIR
|
|
fanotify_flags = FAN_CLASS_PRE_CONTENT, FAN_CLASS_CONTENT, FAN_CLASS_NOTIF, FAN_CLOEXEC, FAN_NONBLOCK, FAN_UNLIMITED_QUEUE, FAN_UNLIMITED_MARKS, FAN_ENABLE_AUDIT
|
|
fanotify_events = O_RDONLY, O_WRONLY, O_RDWR, O_LARGEFILE, O_CLOEXEC, O_APPEND, O_DSYNC, O_NOATIME, O_NONBLOCK, O_SYNC
|
|
fanotify_mark = FAN_MARK_ADD, FAN_MARK_REMOVE, FAN_MARK_FLUSH, FAN_MARK_DONT_FOLLOW, FAN_MARK_ONLYDIR, FAN_MARK_MOUNT, FAN_MARK_IGNORED_MASK, FAN_MARK_IGNORED_SURV_MODIFY
|
|
fanotify_mask = FAN_ACCESS, FAN_MODIFY, FAN_CLOSE_WRITE, FAN_CLOSE_NOWRITE, FAN_OPEN, FAN_OPEN_PERM, FAN_ACCESS_PERM, FAN_ONDIR, FAN_EVENT_ON_CHILD
|
|
faccessat_flags = 0x100, 0x200, 0x400, 0x800, 0x1000
|
|
futex_op = FUTEX_WAIT, FUTEX_WAIT_BITSET, FUTEX_WAKE, FUTEX_REQUEUE, FUTEX_CMP_REQUEUE
|
|
sync_file_flags = SYNC_FILE_RANGE_WAIT_BEFORE, SYNC_FILE_RANGE_WRITE, SYNC_FILE_RANGE_WAIT_AFTER
|
|
kcmp_flags = KCMP_FILE, KCMP_FILES, KCMP_FS, KCMP_IO, KCMP_SIGHAND, KCMP_SYSVSEM, KCMP_VM
|
|
rusage_who = RUSAGE_SELF, RUSAGE_CHILDREN, RUSAGE_THREAD
|
|
rlimit_type = RLIMIT_AS, RLIMIT_CORE, RLIMIT_CPU, RLIMIT_DATA, RLIMIT_FSIZE, RLIMIT_LOCKS, RLIMIT_MEMLOCK, RLIMIT_MSGQUEUE, RLIMIT_NICE, RLIMIT_NOFILE, RLIMIT_NPROC, RLIMIT_RSS, RLIMIT_RTPRIO, RLIMIT_RTTIME, RLIMIT_SIGPENDING, RLIMIT_STACK
|
|
# The ones that disable console output are intentionally omitted.
|
|
syslog_cmd = SYSLOG_ACTION_CLOSE, SYSLOG_ACTION_OPEN, SYSLOG_ACTION_READ, SYSLOG_ACTION_READ_ALL, SYSLOG_ACTION_READ_CLEAR, SYSLOG_ACTION_CLEAR, SYSLOG_ACTION_CONSOLE_ON, SYSLOG_ACTION_CONSOLE_OFF, SYSLOG_ACTION_SIZE_UNREAD, SYSLOG_ACTION_SIZE_BUFFER
|
|
ioprio_which_pid = IOPRIO_WHO_PROCESS, IOPRIO_WHO_PGRP
|
|
ioprio_which_uid = IOPRIO_WHO_USER
|
|
personality_flags = PER_LINUX, PER_SVR4, PER_SVR3, PER_OSR5, PER_WYSEV386, PER_ISCR4, PER_BSD, PER_XENIX, PER_LINUX32, PER_IRIX32, PER_IRIXN32, PER_IRIX64, PER_RISCOS, PER_SOLARIS, PER_UW7, PER_OSF4, PER_HPUX, ADDR_NO_RANDOMIZE, MMAP_PAGE_ZERO, ADDR_COMPAT_LAYOUT, READ_IMPLIES_EXEC, ADDR_LIMIT_32BIT, SHORT_INODE, WHOLE_SECONDS, STICKY_TIMEOUTS, ADDR_LIMIT_3GB
|
|
clock_id = CLOCK_REALTIME, CLOCK_REALTIME_COARSE, CLOCK_MONOTONIC, CLOCK_MONOTONIC_COARSE, CLOCK_MONOTONIC_RAW, CLOCK_BOOTTIME, CLOCK_PROCESS_CPUTIME_ID, CLOCK_THREAD_CPUTIME_ID
|
|
sigprocmask_how = SIG_BLOCK, SIG_UNBLOCK, SIG_SETMASK
|
|
getitimer_which = ITIMER_REAL, ITIMER_VIRTUAL, ITIMER_PROF
|
|
wait_options = WNOHANG, WUNTRACED, WCONTINUED, WEXITED, WSTOPPED, WCONTINUED, WNOHANG, WNOWAIT, __WCLONE, __WALL, __WNOTHREAD
|
|
waitid_which = P_PID, P_PGID, P_ALL
|
|
sigaction_flags = SA_NOCLDSTOP, SA_NOCLDWAIT, SA_NODEFER, SA_ONSTACK, SA_RESETHAND, SA_RESTART, SA_SIGINFO
|
|
timer_flags = 0, TIMER_ABSTIME
|
|
utimensat_flags = 0, AT_SYMLINK_NOFOLLOW
|
|
priority_which = PRIO_PROCESS, PRIO_PGRP, PRIO_USER
|
|
sched_policy = SCHED_NORMAL, SCHED_BATCH, SCHED_IDLE, SCHED_FIFO, SCHED_RR, SCHED_DEADLINE
|
|
sched_attr_flags = 0
|
|
sched_attr_flags2 = 0, SCHED_FLAG_RESET_ON_FORK
|
|
sched_attr_size = 48
|
|
mempolicy_flags = 0, MPOL_F_MEMS_ALLOWED, MPOL_F_ADDR, MPOL_F_NODE
|
|
ptrace_req = PTRACE_TRACEME, PTRACE_LISTEN, PTRACE_KILL, PTRACE_INTERRUPT, PTRACE_ATTACH, PTRACE_DETACH
|
|
ptrace_req_peek = PTRACE_PEEKTEXT, PTRACE_PEEKDATA
|
|
ptrace_req_poke = PTRACE_POKETEXT, PTRACE_POKEDATA
|
|
ptrace_req_getregs = PTRACE_GETREGS, PTRACE_GETFPREGS
|
|
ptrace_req_setregs = PTRACE_SETREGS, PTRACE_SETFPREGS
|
|
ptrace_req_setopts = PTRACE_SETOPTIONS, PTRACE_SEIZE
|
|
ptrace_req_cont = PTRACE_CONT, PTRACE_SYSCALL, PTRACE_SINGLESTEP, PTRACE_SYSEMU, PTRACE_SYSEMU_SINGLESTEP
|
|
pthread_regset = NT_PRSTATUS, NT_PRFPREG, NT_PRPSINFO, NT_TASKSTRUCT, NT_AUXV, NT_386_TLS, NT_386_IOPERM, NT_X86_XSTATE
|
|
ptrace_options = PTRACE_O_EXITKILL, PTRACE_O_TRACECLONE, PTRACE_O_TRACEEXEC, PTRACE_O_TRACEEXIT, PTRACE_O_TRACEFORK, PTRACE_O_TRACESYSGOOD, PTRACE_O_TRACEVFORK, PTRACE_O_TRACEVFORKDONE
|
|
fcntl_dupfd = F_DUPFD, F_DUPFD_CLOEXEC
|
|
fcntl_getflags = F_GETFD, F_GETFL, F_GETSIG, F_GETLEASE, F_GETPIPE_SZ, F_GET_SEALS
|
|
fcntl_lock = F_SETLK, F_SETLKW, F_GETLK
|
|
fcntl_flags = FD_CLOEXEC
|
|
fcntl_status = O_APPEND, FASYNC, O_DIRECT, O_NOATIME, O_NONBLOCK
|
|
flock_type = F_RDLCK, F_WRLCK, F_UNLCK
|
|
f_owner_type = F_OWNER_TID, F_OWNER_PID, F_OWNER_PGRP
|
|
fcntl_notify = DN_MULTISHOT, DN_ACCESS, DN_MODIFY, DN_CREATE, DN_DELETE, DN_RENAME, DN_ATTRIB
|
|
seal_types = F_SEAL_SEAL, F_SEAL_SHRINK, F_SEAL_GROW, F_SEAL_WRITE
|
|
ioctl_void = FIOCLEX, FIONCLEX, FIFREEZE, FITHAW
|
|
ioctl_int_in = FIONBIO, FIOASYNC
|
|
ioctl_int_out = FIOQSIZE, FIGETBSZ
|
|
fcntl_rw_hint = RWF_WRITE_LIFE_NOT_SET, RWH_WRITE_LIFE_NONE, RWH_WRITE_LIFE_SHORT, RWH_WRITE_LIFE_MEDIUM, RWH_WRITE_LIFE_LONG, RWH_WRITE_LIFE_EXTREME
|
|
fiemap_flags = FIEMAP_FLAG_SYNC, FIEMAP_FLAG_XATTR, FIEMAP_FLAG_CACHE
|
|
fiemap_extent_flags = FIEMAP_EXTENT_LAST, FIEMAP_EXTENT_UNKNOWN, FIEMAP_EXTENT_DELALLOC, FIEMAP_EXTENT_ENCODED, FIEMAP_EXTENT_DATA_ENCRYPTED, FIEMAP_EXTENT_NOT_ALIGNED, FIEMAP_EXTENT_DATA_INLINE, FIEMAP_EXTENT_DATA_TAIL, FIEMAP_EXTENT_UNWRITTEN, FIEMAP_EXTENT_MERGED, FIEMAP_EXTENT_SHARED
|
|
getrandom_flags = GRND_NONBLOCK, GRND_RANDOM
|
|
clone_flags = CLONE_VM, CLONE_FS, CLONE_FILES, CLONE_SIGHAND, CLONE_PTRACE, CLONE_VFORK, CLONE_PARENT, CLONE_THREAD, CLONE_NEWNS, CLONE_SYSVSEM, CLONE_SETTLS, CLONE_PARENT_SETTID, CLONE_CHILD_CLEARTID, CLONE_UNTRACED, CLONE_CHILD_SETTID, CLONE_NEWCGROUP, CLONE_NEWUTS, CLONE_NEWIPC, CLONE_NEWUSER, CLONE_NEWPID, CLONE_NEWNET, CLONE_IO
|
|
|
|
kcov_ioctls = KCOV_INIT_TRACE, KCOV_ENABLE, KCOV_DISABLE
|
|
kcov_modes = KCOV_TRACE_PC, KCOV_TRACE_CMP
|
|
|
|
legacy_mmap_number = __NR_mmap2
|
|
|
|
# Not yet implemented syscalls
|
|
#define __NR_umask 95
|
|
#define __NR_vhangup 153
|
|
#define __NR__sysctl 156
|
|
#define __NR_adjtimex 159
|
|
#define __NR_swapon 167
|
|
#define __NR_swapoff 168
|
|
#define __NR_quotactl 179
|
|
#define __NR_nfsservctl 180
|
|
#define __NR_getcpu 309
|
|
|
|
# Probably no sense in calling there.
|
|
# Also affect system-wide state, so not reproducble anyway.
|
|
#define __NR_gettimeofday 96
|
|
#define __NR_settimeofday 164
|
|
#define __NR_reboot 169
|
|
#define __NR_sethostname 170
|
|
#define __NR_setdomainname 171
|
|
#define __NR_sched_get_priority_max 146
|
|
#define __NR_sched_get_priority_min 147
|