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>
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)
#include <unistd.h> int close(int fd);d d #include <sys/types.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>
#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
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>d d #include <signal.h>
#include <signal.h> int kill(pid_t pid, int sig);
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>
#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);
#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>
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>
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);
#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>
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>