d #include <unistd.h>

void _exit(int status);   d d #include <sys/types.h>

#include <sys/socket.h>

int accept(int s, struct sockaddr *addr, socklen_t *addrlen);   d d

#include <unistd.h>

int access(const char *pathname, int mode);
  d d
#include <unistd.h>

int acct(const char *filename);
  d d #include <sys/timex.h>

int adjtimex(struct timex *buf);   d d

#include <unistd.h>

unsigned int alarm(unsigned int seconds);
  d d
int bdflush(int func, long *address);
int bdflush(int func, long data);
  d d #include <sys/types.h>
#include <sys/socket.h>

int bind(int sockfd, struct sockaddr *my_addr, socklen_t addrlen);   d d #include <unistd.h>

int brk(void *end_data_segment);

void *sbrk(ptrdiff_t increment);   d d

#include <asm/cachectl.h>

int cacheflush(char *addr, int nbytes, int cache);
  d d #include <unistd.h>

int chdir(const char *path);
int fchdir(int fd);   d d #include <sys/types.h>
#include <sys/stat.h>

int chmod(const char *path, mode_t mode);
int fchmod(int fildes, mode_t mode);   d d #include <sys/types.h>
#include <unistd.h>

int chown(const char *path, uid_t owner, gid_t group);
int fchown(int fd, uid_t owner, gid_t group);
int lchown(const char *path, uid_t owner, gid_t group);   d d #include <unistd.h>

int chroot(const char *path);   d d #include <sched.h>

int __clone(int (*fn) (void *arg), void *child_stack, int flags, void *arg)

  d d

#include <unistd.h>

int close(int fd);
  d d #include <sys/types.h>
#include <sys/socket.h>

int connect(int sockfd, struct sockaddr *serv_addr, socklen_t addrlen );   d d

#include <unistd.h>

int dup(int oldfd);
int dup2(int oldfd, int newfd);
  d d #include <unistd.h>

int execve (const char *filename, char *const argv [], char *const envp[]);   d d

#include <unistd.h>
#include <fcntl.h>

int fcntl(int fd, int cmd);
int fcntl(int fd, int cmd, long arg);
int fcntl(int fd, int cmd, struct flock * lock);
  d d #include <unistd.h>

#ifdef _POSIX_SYNCHRONIZED_IO

int fdatasync(int fd);

#endif   d d #include <sys/file.h>

int flock(int fd, int operation)   d d #include <unistd.h>

pid_t fork(void);
pid_t vfork(void);   d d #include <unistd.h>

int fsync(int fd);   d d

#include <unistd.h>
#include <linux/dirent.h>
#include <linux/unistd.h>

_syscall3(int, getdents, uint, fd, struct dirent *, dirp, uint, count);

int getdents(unsigned int fd, struct dirent *dirp, unsigned int count);
  d d #include <unistd.h>

int getdomainname(char *name, size_t len);
int setdomainname(const char *name, size_t len);   d d #include <unistd.h>

int getdtablesize(void);   d d #include <unistd.h>
#include <sys/types.h>

gid_t getgid(void);
gid_t getegid(void);   d d #include <unistd.h>

int getgroups(int size, gid_t list[]);

#define __USE_BSD
#include <grp.h>

int setgroups(size_t size, const gid_t *list);   d d #include <unistd.h>

long int gethostid(void);
int sethostid(long int hostid);   d d #include <unistd.h>

int gethostname(char *name, size_t len);
int sethostname(const char *name, size_t len);   d d

#include <sys/time.h>

int getitimer(int which, struct itimerval *value);
int setitimer(int which, const struct itimerval *value, struct itimerval *ovalue);
  d d #include <unistd.h>

size_t getpagesize(void);   d d #include <sys/socket.h>

int getpeername(int s, struct sockaddr *name, socklen_t *namelen);   d d #include <unistd.h>

pid_t getpid(void);
pid_t getppid(void);   d d #include <sys/time.h>
#include <sys/resource.h>

int getpriority(int which, int who);
int setpriority(int which, int who, int prio);   d d #include <unistd.h>

int getresuid(uid_t *ruid, uid_t *euid, uid_t *suid);
int getresgid(gid_t *rgid, gid_t *egid, gid_t *sgid);   d d #include <sys/time.h>
#include <sys/resource.h>
#include <unistd.h>

int getrlimit (int resource, struct rlimit *rlim);
int getrusage (int who, struct rusage *usage);
int setrlimit (int resource, const struct rlimit *rlim);   d d #include <unistd.h>

pid_t getsid(pid_t pid);   d d #include <sys/socket.h>

int getsockname(int s , struct sockaddr * name , socklen_t * namelen )   d d #include <sys/types.h>
#include <sys/socket.h>

int getsockopt(int s, int level, int optname, void *optval, socklen_t *optlen);

int setsockopt(int s, int level, int optname, const void *optval, socklen_t optlen);   d d #include <sys/time.h>
#include <unistd.h>

int gettimeofday(struct timeval *tv, struct timezone *tz);
int settimeofday(const struct timeval *tv , const struct timezone *tz);   d d #include <unistd.h>
#include <sys/types.h>

uid_t getuid(void);
uid_t geteuid(void);   d d #include <unistd.h>

void idle(void);   d d #include <sys/ioctl.h>

int ioctl(int d, int request, ...)

[The "third" argument is traditionally char *argp, and will be so named for this discussion.]   d d #include <unistd.h> /* for libc5 */
#include <sys/io.h> /* for glibc */

int ioperm(unsigned long from, unsigned long num, int turn_on);   d d #include <unistd.h> /* for libc5 */
#include <sys/io.h> /* for glibc */

int iopl(int level);   d d int ipc(unsigned int call, int first, int second, int third, void *ptr, long fifth);   d d

#include <sys/types.h>

#include <signal.h> int kill(pid_t pid, int sig);
  d d #include <signal.h>

int killpg(int pgrp, int sig);   d d #include <unistd.h>

int link(const char *oldpath, const char *newpath);   d d #include <sys/socket.h>

int listen(int s, int backlog);   d d #include <unistd.h>

#include <linux/unistd.h>

_syscall5(int, _llseek, uint, fd, ulong, hi, ulong, lo, loff_t *, res, uint, wh);

int _llseek(unsigned int fd, unsigned long offset_high, unsigned long offset_low, loff_t * result, unsigned int whence);   d d #include <sys/types.h>
#include <unistd.h>

off_t lseek(int fildes, off_t offset, int whence);   d d

#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>

int mkdir(const char *pathname, mode_t mode);
  d d
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

int mknod(const char *pathname, mode_t mode, dev_t dev);
  d d
#include <sys/mman.h>

int mlock(const void *addr, size_t len);
  d d
#include <sys/mman.h>

int mlockall(int flags);
  d d #include <unistd.h>
#include <sys/mman.h>

#ifdef _POSIX_MAPPED_FILES

void * mmap(void *start, size_t length, int prot , int flags, int fd, off_t offset);

int munmap(void *start, size_t length);

#endif   d d

#include <linux/ldt.h>
#include <linux/unistd.h>

_syscall3( int, modify_ldt, int, func, void *, ptr, unsigned long, bytecount )

int modify_ldt(int func, void *ptr, unsigned long bytecount);
  d d #include <sys/mount.h>
#include <linux/fs.h> /* very unwise */

int mount(const char *specialfile, const char * dir , const char * filesystemtype, unsigned long rwflag , const void * data);

int umount(const char *specialfile);

int umount(const char *dir);   d d

#include <sys/mman.h>

int mprotect(const void *addr, size_t len, int prot);
  d d #include <unistd.h>
#include <sys/mman.h>

void * mremap(void * old_address, size_t old_size , size_t new_size, unsigned long flags);   d d

# include <sys/types.h>
# include <sys/ipc.h>
# include <sys/msg.h>

int msgctl ( int msqid, int cmd, struct msqid_ds *buf )   d d

# include <sys/types.h>
# include <sys/ipc.h>
# include <sys/msg.h>

int msgget ( key_t key, int msgflg )   d d

# include <sys/types.h>

# include <sys/ipc.h>
# include <sys/msg.h>

int msgsnd ( int msqid, struct msgbuf *msgp, int msgsz, int msgflg )

int msgrcv ( int msqid, struct msgbuf *msgp, int msgsz, long msgtyp, int msgflg )   d d #include <unistd.h>
#include <sys/mman.h>

#ifdef _POSIX_MAPPED_FILES
#ifdef _POSIX_SYNCHRONIZED_IO

int msync(const void *start, size_t length, int flags);

#endif
#endif   d d

#include <sys/mman.h>

int munlock(const void *addr, size_t len);
  d d
#include <sys/mman.h>

int munlockall(void);
  d d #include <time.h>

int nanosleep(const struct timespec *req, struct timespec *rem);   d d #include <linux/nfsd/syscall.h>

nfsservctl(int cmd, struct nfsctl_arg *argp, union nfsctl_res *resp);   d d #include <unistd.h>

int nice(int inc);   d d Obsolete system calls.   d d

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int open(const char *pathname, int flags);
int open(const char *pathname, int flags, mode_t mode);
int creat(const char *pathname, mode_t mode);
  d d #include <unistd.h>

int pause(void);   d d int personality(unsigned long persona);   d d #include <unistd.h>

int pipe(int filedes[2]);   d d #include <sys/poll.h>

int poll(struct pollfd *ufds, unsigned int nfds, int timeout);   d d #include <linux/prctl.h>

int prctl(int option, unsigned long arg2, unsigned long arg3 , unsigned long arg4, unsigned long arg5);   d d #include <sys/ptrace.h>

int ptrace(int request, int pid, int addr, int data);   d d #include <sys/types.h>
#include <sys/quota.h>

int quotactl (int cmd, const char *special, int id , caddr_t addr);

#include <linux/unistd.h>

_syscall4(int, quotactl, int, cmd, const char *, special , int, id, caddr_t, addr);   d d

#include <unistd.h>

ssize_t read(int fd, void *buf, size_t count);
  d d
#include <unistd.h>
#include <linux/dirent.h>
#include <linux/unistd.h>

_syscall3(int, readdir, uint, fd, struct dirent *, dirp, uint, count);

int readdir(unsigned int fd, struct dirent *dirp, unsigned int count);
  d d #include <unistd.h>

int readlink(const char *path, char *buf, size_t bufsiz);   d d #include <sys/uio.h>

int readv(int fd, const struct iovec * vector, int count);

int writev(int fd, const struct iovec * vector, int count);

struct iovec {

  __ptr_t iov_base; /* Starting address.  */

  size_t iov_len; /* Length in bytes.  */
};   d d For libc4 and libc5 the library call and the system call are identical, and since kernel version 2.1.30 there are symbolic names LINUX_REBOOT_* for the constants and a fourth argument to the call:

#include <unistd.h>
#include <linux/reboot.h>

int reboot (int magic, int magic2, int flag, void *arg);

Under glibc some of the constants involved have gotten symbolic names RB_*, and the library call is a 1-argument wrapper around the 3-argument system call:

#include <unistd.h>
#include <sys/reboot.h>

int reboot (int flag);   d d #include <sys/types.h>
#include <sys/socket.h>

int recv(int s, void *buf, int len, unsigned int flags);

int recvfrom(int s, void *buf, int len, unsigned int flags struct sockaddr *from, socklen_t *fromlen);

int recvmsg(int s, struct msghdr *msg, unsigned int flags);   d d #include <stdio.h>

int rename(const char *oldpath, const char *newpath);   d d #include <unistd.h>

int rmdir(const char *pathname);   d d #include <sched.h>

int sched_get_priority_max(int policy);

int sched_get_priority_min(int policy);   d d #include <sched.h>

int sched_rr_get_interval(pid_t pid, struct timespec *tp);


struct timespec {
    time_t  tv_sec;     /* seconds */
    long    tv_nsec;    /* nanoseconds */
};

  d d #include <sched.h>

int sched_setparam(pid_t pid, const struct sched_param *p);

int sched_getparam(pid_t pid, struct sched_param *p);


struct sched_param {
    ...
    int sched_priority;
    ...
};

  d d #include <sched.h>

int sched_setscheduler(pid_t pid, int policy, const struct sched_param *p);

int sched_getscheduler(pid_t pid);


struct sched_param {
    ...
    int sched_priority;
    ...
};

  d d #include <sched.h>

int sched_yield(void);   d d #include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>

int select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);

FD_CLR(int fd, fd_set *set);
FD_ISSET(int fd, fd_set *set);
FD_SET(int fd, fd_set *set);
FD_ZERO(fd_set *set);   d d

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

#if defined(__GNU_LIBRARY__) && !defined(_SEM_SEMUN_UNDEFINED)
/* union semun is defined by including <sys/sem.h> */
#else
/* according to X/OPEN we have to define it ourselves */
union semun {
        int val;                    /* value for SETVAL */
        struct semid_ds *buf;       /* buffer for IPC_STAT, IPC_SET */
        unsigned short int *array;  /* array for GETALL, SETALL */
        struct seminfo *__buf;      /* buffer for IPC_INFO */
};
#endif

int semctl (int semid, int semnum, int cmd, union semun arg)   d d

# include <sys/types.h>
# include <sys/ipc.h>
# include <sys/sem.h>

int semget ( key_t key, int nsems, int semflg )   d d

# include <sys/types.h>
# include <sys/ipc.h>
# include <sys/sem.h>

int semop ( int semid, struct sembuf *sops, unsigned nsops )   d d #include <sys/types.h>
#include <sys/socket.h>

int send(int s, const void *msg, size_t len, int flags);

int sendto(int s, const void *msg, size_t len, int flags, const struct sockaddr *to, socklen_t tolen);

int sendmsg(int s, const struct msghdr *msg, int flags);   d d int setfsgid(uid_t fsgid)   d d int setfsuid(uid_t fsuid)   d d #include <unistd.h>

int setgid(gid_t gid)   d d #include <unistd.h>

int setpgid(pid_t pid, pid_t pgid);
pid_t getpgid(pid_t pid);
int setpgrp(void);
pid_t getpgrp(void);   d d #include <unistd.h>

int setregid(gid_t rgid, gid_t egid);
int setegid(gid_t egid);   d d #include <unistd.h>

int setresuid(uid_t ruid, uid_t euid, uid_t suid);
int setresgid(gid_t rgid, gid_t egid, gid_t sgid);   d d #include <unistd.h>

int setreuid(uid_t ruid, uid_t euid);
int seteuid(uid_t euid);   d d #include <unistd.h>

pid_t setsid(void);
  d d #include <unistd.h>

int setuid(uid_t uid)   d d #include <unistd.h>

_syscall0(int, setup);

int setup(void);   d d #include <sys/ipc.h>

#include <sys/shm.h>

int shmctl(int shmid, int cmd, struct shmid_ds *buf);   d d #include <sys/ipc.h>

#include <sys/shm.h>

int shmget(key_t key, int size, int shmflg);   d d

# include <sys/types.h>
# include <sys/ipc.h>
# include <sys/shm.h>

char *shmat ( int shmid, char *shmaddr, int shmflg )

int shmdt ( char *shmaddr)   d d #include <sys/socket.h>

int shutdown(int s, int how);   d d #include <signal.h>

int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);

int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);

int sigpending(sigset_t *set);

int sigsuspend(const sigset_t *mask);

  d d #include <signal.h>

int sigblock(int mask);

int siggetmask(void);

int sigsetmask(int mask);

int sigmask(int signum);   d d #include <signal.h>

void (*signal(int signum, void (*handler)(int)))(int);

  d d #include <signal.h>

int sigpause(int sigmask);

  d d int sigreturn(unsigned long __unused);   d d #include <bsd/signal.h>

int sigvec(int sig, struct sigvec *vec, struct sigvec *ovec);

  d d #include <sys/types.h>
#include <sys/socket.h>

int socket(int domain, int type, int protocol);   d d int socketcall(int call, unsigned long *args);   d d #include <sys/types.h>
#include <sys/socket.h>

int socketpair(int d, int type, int protocol, int sv[2]);   d d #include <sys/stat.h>
#include <unistd.h>

int stat(const char *file_name, struct stat *buf);
int fstat(int filedes, struct stat *buf);
int lstat(const char *file_name, struct stat *buf);   d d #include <sys/vfs.h>

int statfs(const char *path, struct statfs *buf);
int fstatfs(int fd, struct statfs *buf);   d d #include <time.h>

int stime(time_t *t);   d d #include <unistd.h>
#include <asm/page.h> /* to find PAGE_SIZE */
#include <sys/swap.h>

int swapon(const char *path, int swapflags);
int swapoff(const char *path);   d d #include <unistd.h>

int symlink(const char *oldpath, const char *newpath);   d d #include <unistd.h>

int sync(void);   d d Linux 2.0 system calls.   d d #include <unistd.h>

#include <linux/unistd.h>

#include <linux/sysctl.h>

_syscall1(int, _sysctl, struct __sysctl_args *, args);

int _sysctl(struct __sysctl_args *args);   d d int sysfs(int option, const char * fsname);

int sysfs(int option, unsigned int fs_index, char * buf);

int sysfs(int option);   d d #include <linux/kernel.h>
#include <linux/sys.h>

int sysinfo(struct sysinfo *info);   d d

#include <unistd.h>

#include <linux/unistd.h>

_syscall3(int, syslog, int, type, char *, bufp, int, len);

int syslog(int type, char *bufp, int len);
  d d #include <time.h>

time_t time(time_t *t);   d d #include <sys/times.h>

clock_t times(struct tms *buf);   d d #include <unistd.h>

int truncate(const char *path, off_t length);
int ftruncate(int fd, off_t length);   d d #include <sys/types.h>
#include <sys/stat.h>

mode_t umask(mode_t mask);   d d #include <sys/utsname.h>

int uname(struct utsname *buf);   d d Undocumented system calls.   d d Unimplemented system calls.   d d #include <unistd.h>

int unlink(const char *pathname);   d d #include <unistd.h>

int uselib(const char *library);   d d

#include <sys/types.h>

int ustat(dev_t dev, struct ustat * ubuf);
  d d #include <sys/types.h>
#include <utime.h>

int utime(const char *filename, struct utimbuf *buf);

#include <sys/time.h>

int utimes(char *filename, struct timeval *tvp);   d d #include <unistd.h>

int vhangup(void);   d d #include <sys/vm86.h>

int vm86old(struct vm86_struct * info);

int vm86(unsigned long fn, struct vm86plus_struct * v86);   d d #include <sys/types.h>
#include <sys/wait.h>

pid_t wait(int *status)
pid_t waitpid(pid_t pid, int *status, int options);   d d

#define _USE_BSD
#include <sys/types.h>
#include <sys/resource.h>
#include <sys/wait.h>

pid_t wait3(int *status, int options,
      struct rusage *rusage)

pid_t wait4(pid_t pid, int *status, int options,
      struct rusage *rusage)
  d d #include <unistd.h>

ssize_t write(int fd, const void *buf, size_t count);   d