# -*- 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,ia64,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)
long init_module(void *, unsigned long, const char *)
long delete_module(const char *, unsigned int)
<!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)
