# -*- fundamental -*-
#
# This is a list of system calls we invoke "directly".  These
# are generated into syscall stubs in their own C files, so the
# linker can do its job properly.
#
# The full description of a line is:
# [<[!]arch,...>] type sysname[@systype][::funcname](args)
#

#
# Process-related syscalls
#
<!mips,mips64,sparc,ia64> pid_t vfork()
<sparc> pid_t vfork@forkish()
<!alpha> pid_t getpid()
<alpha> pid_t getxpid@dual0::getpid()
int setpgid(pid_t, pid_t)
pid_t getpgid(pid_t)
<!alpha> pid_t getppid()
<alpha> pid_t getxpid@dual1::getppid()
<!ia64> pid_t getpgrp()
pid_t setsid()
pid_t getsid(pid_t)
pid_t wait4(pid_t, int *, int, struct rusage *)
int execve(const char *, char * const *, char * const *)
int setpriority(int, int, int)
int sched_setscheduler(pid_t, int, const struct sched_param *)
int sched_yield()

#
# User and group IDs
#
int setuid(uid_t)
int setgid(gid_t)
<!alpha> uid_t getuid()
<alpha> uid_t getxuid@dual0::getuid()
<!alpha> gid_t getgid()
<alpha> gid_t getxgid@dual0::getgid()
<!alpha> uid_t geteuid()
<alpha> uid_t getxuid@dual1::geteuid()
<!alpha> gid_t getegid()
<alpha> uid_t getxgid@dual1::getegid()
int getgroups(int, gid_t *)
int setgroups(size_t, const gid_t *)
int setreuid(uid_t, uid_t)
int setregid(gid_t, gid_t)
int setfsuid(uid_t)
int setfsgid(gid_t)

#
# Filesystem-related system calls
#
int mount(const char *, const char *, const char *, unsigned long, const void *)
<!alpha,ia64> int umount2(const char *, int)
<alpha,ia64> int umount::umount2(const char *, int)
<!m68k> int pivot_root(const char *, const char *)
int sync()
int statfs(const char *, struct statfs *)
int fstatfs(int, struct statfs *)
int swapon(const char *, int)
int swapoff(const char *)

#
# Inode-related system calls
#
int access(const char *, int)
int link(const char *, const char *)
int unlink(const char *)
int chdir(const char *)
int rename(const char *, const char *)
int mknod(const char *, mode_t, dev_t)
int chmod(const char *, mode_t)
int mkdir(const char *, mode_t)
int rmdir(const char *)
<!alpha,mips,mips64> int pipe(int *)
mode_t umask(mode_t)
int chroot(const char *)
int symlink(const char *, const char *)
int readlink(const char *, char *, size_t)
int stat(const char *, struct stat *)
int lstat(const char *, struct stat *)
int fstat(int, struct stat *)
int getdents(unsigned int, struct dirent *, unsigned int)
int chown(const char *, uid_t, gid_t)
int fchown(int, uid_t, gid_t)
int lchown(const char *, uid_t, gid_t)

#
# I/O operations
#
ssize_t read(int, void *, size_t)
ssize_t write(int, const void *, size_t)
int open(const char *, int, mode_t)
int close(int)
off_t lseek(int, off_t, int)
int dup(int)
int dup2(int, int)
int fcntl(int, int, long)
int ioctl(int, int, void *)
int flock(int, int)
int poll(struct pollfd *, nfds_t, long)
int fsync(int)
int readv(int, const struct iovec *, int)
int writev(int, const struct iovec *, int)
int ftruncate(int, off_t)

#
# Signal operations
#
int kill(pid_t, int)
int rt_sigaction(int, const struct sigaction *, struct sigaction *, size_t)
int rt_sigsuspend(const sigset_t *, size_t)
int rt_sigpending(sigset_t *, size_t)
int rt_sigprocmask(int, const sigset_t *, sigset_t *, size_t)
int getitimer(int, struct itimerval *)
int setitimer(int, const struct itimerval *, struct itimerval *)

#
# Time-related system calls
#
clock_t times(struct tms *)
int gettimeofday(struct timeval *, struct timezone *)
int settimeofday(const struct timeval *, const struct timezone *)
int nanosleep(const struct timespec *, struct timespec *)

#
# Memory
#
void * brk::__brk(void *)
int munmap(void *, size_t)
void * mremap(void *, size_t, size_t, unsigned long)
int msync(const void *, size_t, int)
int mprotect(const void *, size_t, int)

#
# System stuff
#
int uname(struct utsname *)
int setdomainname(const char *, size_t)
int sethostname(const char *, size_t)
int init_module(const char *, struct module *)
<!ia64> void * create_module(const char *, size_t)
int delete_module(const char *)
<!ia64> int query_module(const char *, int, void *, size_t, size_t)
int reboot::__reboot(int, int, int, void *)
int syslog::klogctl(int, char *, int)
