$Id: syscalls.master,v 1.22 1996/01/04 20:28:48 wollman Exp $ ; from: @(#)syscalls.master 8.2 (Berkeley) 1/13/94 ; ; System call name/number master file. ; Processed to created init_sysent.c, syscalls.c and syscall.h. ; Columns: number type nargs namespc name alt{name,tag,rtyp}/comments ; number system call number, must be in order ; type one of STD, OBSOL, UNIMPL, COMPAT ; namespc one of POSIX, BSD, NOHIDE ; name psuedo-prototype of syscall routine ; If one of the following alts is different, then all appear: ; altname name of system call if different ; alttag name of args struct tag if different from [o]`name'"_args" ; altrtyp return type if not int (bogus - syscalls always return int) ; for UNIMPL/OBSOL, name continues with comments ; types: ; STD always included ; COMPAT included on COMPAT #ifdef ; LIBCOMPAT included on COMPAT #ifdef, and placed in syscall.h ; OBSOL obsolete, not included in system, only specifies name ; UNIMPL not implemented, placeholder only ; #ifdef's, etc. may be included, and are copied to the output files. #include "opt_sysvipc.h" #include #include #include #include #include ; Reserved/unimplemented system calls in the range 0-150 inclusive ; are reserved for use in future Berkeley releases. ; Additional system calls implemented in vendor and other ; redistributions should be placed in the reserved range at the end ; of the current calls. 0 STD NOHIDE { int nosys(void); } syscall nosys_args int 1 STD NOHIDE { void exit(int rval); } exit rexit_args void 2 STD POSIX { int fork(void); } 3 STD POSIX { int read(int fd, char *buf, u_int nbyte); } 4 STD POSIX { int write(int fd, char *buf, u_int nbyte); } 5 STD POSIX { int open(char *path, int flags, int mode); } ; XXX should be { int open(const char *path, int flags, ...); } ; but we're not ready for `const' or varargs. ; XXX man page says `mode_t mode'. 6 STD POSIX { int close(int fd); } 7 STD BSD { int wait4(int pid, int *status, int options, \ struct rusage *rusage); } wait4 wait_args int 8 COMPAT BSD { int creat(char *path, int mode); } 9 STD POSIX { int link(char *path, char *link); } 10 STD POSIX { int unlink(char *path); } 11 OBSOL NOHIDE execv 12 STD POSIX { int chdir(char *path); } 13 STD BSD { int fchdir(int fd); } 14 STD POSIX { int mknod(char *path, int mode, int dev); } 15 STD POSIX { int chmod(char *path, int mode); } 16 STD POSIX { int chown(char *path, int uid, int gid); } 17 STD BSD { int obreak(char *nsize); } break obreak_args int 18 STD BSD { int getfsstat(struct statfs *buf, long bufsize, \ int flags); } 19 COMPAT POSIX { long lseek(int fd, long offset, int whence); } 20 STD POSIX { pid_t getpid(void); } 21 STD BSD { int mount(int type, char *path, int flags, \ caddr_t data); } ; XXX 4.4lite2 uses `char *type' but we're not ready for that. ; XXX `path' should have type `const char *' but we're not ready for that. 22 STD BSD { int unmount(char *path, int flags); } 23 STD POSIX { int setuid(uid_t uid); } 24 STD POSIX { uid_t getuid(void); } 25 STD POSIX { uid_t geteuid(void); } 26 STD BSD { int ptrace(int req, pid_t pid, caddr_t addr, \ int data); } 27 STD BSD { int recvmsg(int s, struct msghdr *msg, int flags); } 28 STD BSD { int sendmsg(int s, caddr_t msg, int flags); } 29 STD BSD { int recvfrom(int s, caddr_t buf, size_t len, \ int flags, caddr_t from, int *fromlenaddr); } 30 STD BSD { int accept(int s, caddr_t name, int *anamelen); } 31 STD BSD { int getpeername(int fdes, caddr_t asa, int *alen); } 32 STD BSD { int getsockname(int fdes, caddr_t asa, int *alen); } 33 STD POSIX { int access(char *path, int flags); } 34 STD BSD { int chflags(char *path, int flags); } 35 STD BSD { int fchflags(int fd, int flags); } 36 STD BSD { int sync(void); } 37 STD POSIX { int kill(int pid, int signum); } 38 COMPAT POSIX { int stat(char *path, struct ostat *ub); } 39 STD POSIX { pid_t getppid(void); } 40 COMPAT POSIX { int lstat(char *path, struct ostat *ub); } 41 STD POSIX { int dup(u_int fd); } 42 STD POSIX { int pipe(void); } 43 STD POSIX { gid_t getegid(void); } 44 STD BSD { int profil(caddr_t samples, u_int size, \ u_int offset, u_int scale); } 45 STD BSD { int ktrace(char *fname, int ops, int facs, \ int pid); } 46 STD POSIX { int sigaction(int signum, struct sigaction *nsa, \ struct sigaction *osa); } 47 STD POSIX { gid_t getgid(void); } 48 STD POSIX { int sigprocmask(int how, sigset_t mask); } 49 STD BSD { int getlogin(char *namebuf, u_int namelen); } 50 STD BSD { int setlogin(char *namebuf); } 51 STD BSD { int acct(char *path); } 52 STD POSIX { int sigpending(void); } 53 STD BSD { int sigaltstack(struct sigaltstack *nss, \ struct sigaltstack *oss); } 54 STD POSIX { int ioctl(int fd, u_long com, caddr_t data); } 55 STD BSD { int reboot(int opt); } 56 STD POSIX { int revoke(char *path); } 57 STD POSIX { int symlink(char *path, char *link); } 58 STD POSIX { int readlink(char *path, char *buf, int count); } 59 STD POSIX { int execve(char *fname, char **argv, char **envv); } 60 STD POSIX { int umask(int newmask); } umask umask_args mode_t 61 STD BSD { int chroot(char *path); } 62 COMPAT POSIX { int fstat(int fd, struct ostat *sb); } 63 COMPAT BSD { int getkerninfo(int op, char *where, int *size, \ int arg); } getkerninfo getkerninfo_args int 64 COMPAT BSD { int getpagesize(void); } \ getpagesize getpagesize_args int 65 STD BSD { int msync(caddr_t addr, int len, int flags); } ; XXX should be { int msync(caddr_t addr, size_t len, int flags); } ; but man page and old args struct have `int len'. 66 NOARGS BSD { int vfork(void); } vfork fork_args int 67 OBSOL NOHIDE vread 68 OBSOL NOHIDE vwrite 69 STD BSD { int sbrk(int incr); } 70 STD BSD { int sstk(int incr); } 71 COMPAT BSD { int mmap(caddr_t addr, int len, int prot, \ int flags, int fd, long pos); } ; XXX should be { int mmap(caddr_t addr, size_t len, int prot, ; int flags, int fd, long pos); } ; but old args struct has `int len'. 72 STD BSD { int ovadvise(int anom); } vadvise ovadvise_args int 73 STD BSD { int munmap(caddr_t addr, int len); } ; XXX should be { int munmap(caddr_t addr, size_t len); } ; but man page and old args struct have `int len'. 74 STD BSD { int mprotect(caddr_t addr, int len, int prot); } ; XXX should be { int mprotect(caddr_t addr, size_t len, int prot); } ; but man page and old args struct have `int len'. 75 STD BSD { int madvise(caddr_t addr, int len, int behav); } ; XXX should be { int madvise(caddr_t addr, size_t len, int behav); } ; but man page, madvise() prototype and old args struct have `int len'. 76 OBSOL NOHIDE vhangup 77 OBSOL NOHIDE vlimit 78 STD BSD { int mincore(caddr_t addr, int len, char *vec); } ; XXX should be { int mincore(caddr_t addr, size_t len, char *vec); } ; but man page, and old args struct have `int len'. ; XXX mincore() prototype isn't in . 79 STD POSIX { int getgroups(u_int gidsetsize, gid_t *gidset); } 80 STD POSIX { int setgroups(u_int gidsetsize, gid_t *gidset); } 81 STD POSIX { int getpgrp(void); } 82 STD POSIX { int setpgid(int pid, int pgid); } 83 STD BSD { int setitimer(u_int which, struct itimerval *itv, \ struct itimerval *oitv); } 84 COMPAT BSD { int wait(void); } 85 STD BSD { int swapon(char *name); } 86 STD BSD { int getitimer(u_int which, struct itimerval *itv); } 87 COMPAT BSD { int gethostname(char *hostname, u_int len); } \ gethostname gethostname_args int 88 COMPAT BSD { int sethostname(char *hostname, u_int len); } \ sethostname sethostname_args int 89 STD BSD { int getdtablesize(void); } 90 STD POSIX { int dup2(u_int from, u_int to); } 91 UNIMPL BSD getdopt 92 STD POSIX { int fcntl(int fd, int cmd, int arg); } ; XXX should be { int fcntl(int fd, int cmd, ...); } ; but we're not ready for varargs. ; XXX man page says `int arg' too. 93 STD BSD { int select(u_int nd, fd_set *in, fd_set *ou, \ fd_set *ex, struct timeval *tv); } 94 UNIMPL BSD setdopt 95 STD POSIX { int fsync(int fd); } 96 STD BSD { int setpriority(int which, int who, int prio); } 97 STD BSD { int socket(int domain, int type, int protocol); } 98 STD BSD { int connect(int s, caddr_t name, int namelen); } 99 CPT_NOA BSD { int accept(int s, caddr_t name, int *anamelen); } \ accept accept_args int 100 STD BSD { int getpriority(int which, int who); } 101 COMPAT BSD { int send(int s, caddr_t buf, int len, int flags); } 102 COMPAT BSD { int recv(int s, caddr_t buf, int len, int flags); } 103 STD BSD { int sigreturn(struct sigcontext *sigcntxp); } 104 STD BSD { int bind(int s, caddr_t name, int namelen); } 105 STD BSD { int setsockopt(int s, int level, int name, \ caddr_t val, int valsize); } 106 STD BSD { int listen(int s, int backlog); } 107 OBSOL NOHIDE vtimes 108 COMPAT BSD { int sigvec(int signum, struct sigvec *nsv, \ struct sigvec *osv); } 109 COMPAT BSD { int sigblock(int mask); } 110 COMPAT BSD { int sigsetmask(int mask); } 111 STD POSIX { int sigsuspend(int mask); } 112 COMPAT BSD { int sigstack(struct sigstack *nss, \ struct sigstack *oss); } 113 COMPAT BSD { int recvmsg(int s, struct omsghdr *msg, int flags); } 114 COMPAT BSD { int sendmsg(int s, caddr_t msg, int flags); } 115 OBSOL NOHIDE vtrace 116 STD BSD { int gettimeofday(struct timeval *tp, \ struct timezone *tzp); } 117 STD BSD { int getrusage(int who, struct rusage *rusage); } 118 STD BSD { int getsockopt(int s, int level, int name, \ caddr_t val, int *avalsize); } 119 UNIMPL NOHIDE nosys 120 STD BSD { int readv(int fd, struct iovec *iovp, u_int iovcnt); } 121 STD BSD { int writev(int fd, struct iovec *iovp, \ u_int iovcnt); } 122 STD BSD { int settimeofday(struct timeval *tv, \ struct timezone *tzp); } 123 STD BSD { int fchown(int fd, int uid, int gid); } 124 STD BSD { int fchmod(int fd, int mode); } 125 CPT_NOA BSD { int recvfrom(int s, caddr_t buf, size_t len, \ int flags, caddr_t from, int *fromlenaddr); } \ recvfrom recvfrom_args int 126 STD BSD { int setreuid(int ruid, int euid); } 127 STD BSD { int setregid(int rgid, int egid); } 128 STD POSIX { int rename(char *from, char *to); } 129 COMPAT BSD { int truncate(char *path, long length); } 130 COMPAT BSD { int ftruncate(int fd, long length); } 131 STD BSD { int flock(int fd, int how); } 132 STD POSIX { int mkfifo(char *path, int mode); } 133 STD BSD { int sendto(int s, caddr_t buf, size_t len, \ int flags, caddr_t to, int tolen); } 134 STD BSD { int shutdown(int s, int how); } 135 STD BSD { int socketpair(int domain, int type, int protocol, \ int *rsv); } 136 STD POSIX { int mkdir(char *path, int mode); } 137 STD POSIX { int rmdir(char *path); } 138 STD BSD { int utimes(char *path, struct timeval *tptr); } 139 OBSOL NOHIDE 4.2 sigreturn 140 STD BSD { int adjtime(struct timeval *delta, \ struct timeval *olddelta); } 141 COMPAT BSD { int getpeername(int fdes, caddr_t asa, int *alen); } 142 COMPAT BSD { long gethostid(void); } 143 COMPAT BSD { int sethostid(long hostid); } 144 COMPAT BSD { int getrlimit(u_int which, struct ogetrlimit *rlp); } 145 COMPAT BSD { int setrlimit(u_int which, struct ogetrlimit *rlp); } 146 COMPAT BSD { int killpg(int pgid, int signum); } 147 STD POSIX { int setsid(void); } 148 STD BSD { int quotactl(char *path, int cmd, int uid, \ caddr_t arg); } 149 COMPAT BSD { int quota(void); } 150 CPT_NOA BSD { int getsockname(int fdec, caddr_t asa, int *alen); }\ getsockname getsockname_args int ; Syscalls 151-180 inclusive are reserved for vendor-specific ; system calls. (This includes various calls added for compatibity ; with other Unix variants.) ; Some of these calls are now supported by BSD... 151 UNIMPL NOHIDE nosys 152 UNIMPL NOHIDE nosys 153 UNIMPL NOHIDE nosys 154 UNIMPL NOHIDE nosys #ifdef NFS 155 STD BSD { int nfssvc(int flag, caddr_t argp); } #else 155 UNIMPL BSD nosys #endif 156 COMPAT BSD { int getdirentries(int fd, char *buf, u_int count, \ long *basep); } 157 STD BSD { int statfs(char *path, struct statfs *buf); } 158 STD BSD { int fstatfs(int fd, struct statfs *buf); } 159 UNIMPL NOHIDE nosys 160 UNIMPL NOHIDE nosys #ifdef NFS 161 STD BSD { int getfh(char *fname, fhandle_t *fhp); } #else 161 UNIMPL BSD nosys #endif 162 STD BSD { int getdomainname(char *domainname, int len); } 163 STD BSD { int setdomainname(char *domainname, int len); } 164 STD BSD { int uname(struct utsname *name); } 165 STD BSD { int sysarch(int op, char *parms); } 166 STD BSD { int rtprio(int function, pid_t pid, \ struct rtprio *rtp); } 167 UNIMPL NOHIDE nosys 168 UNIMPL NOHIDE nosys 169 STD BSD { int semsys(int which, int a2, int a3, int a4, \ int a5); } ; XXX should be { int semsys(int which, ...); } 170 STD BSD { int msgsys(int which, int a2, int a3, int a4, \ int a5, int a6); } ; XXX should be { int msgsys(int which, ...); } 171 STD BSD { int shmsys(int which, int a2, int a3, int a4); } ; XXX should be { int shmsys(int which, ...); } 172 UNIMPL NOHIDE nosys 173 UNIMPL NOHIDE nosys 174 UNIMPL NOHIDE nosys 175 UNIMPL NOHIDE nosys 176 STD BSD { int ntp_adjtime(struct timex *tp); } 177 UNIMPL NOHIDE nosys 178 UNIMPL NOHIDE nosys 179 UNIMPL NOHIDE nosys 180 UNIMPL NOHIDE nosys ; Syscalls 180-199 are used by/reserved for BSD 181 STD POSIX { int setgid(gid_t gid); } 182 STD BSD { int setegid(gid_t egid); } 183 STD BSD { int seteuid(uid_t euid); } #ifdef LFS 184 STD BSD { int lfs_bmapv(fsid_t *fsidp, \ struct block_info *blkiov, int blkcnt); } 185 STD BSD { int lfs_markv(fsid_t *fsidp, \ struct block_info *blkiov, int blkcnt); } 186 STD BSD { int lfs_segclean(fsid_t *fsidp, u_long segment); } 187 STD BSD { int lfs_segwait(fsid_t *fsidp, struct timeval *tv); } #else 184 UNIMPL BSD nosys 185 UNIMPL BSD nosys 186 UNIMPL BSD nosys 187 UNIMPL BSD nosys #endif 188 STD POSIX { int stat(char *path, struct stat *ub); } 189 STD POSIX { int fstat(int fd, struct stat *sb); } 190 STD POSIX { int lstat(char *path, struct stat *ub); } 191 STD POSIX { int pathconf(char *path, int name); } 192 STD POSIX { int fpathconf(int fd, int name); } 193 UNIMPL NOHIDE nosys 194 STD BSD { int getrlimit(u_int which, \ struct orlimit *rlp); } \ getrlimit __getrlimit_args int 195 STD BSD { int setrlimit(u_int which, \ struct orlimit *rlp); } \ setrlimit __setrlimit_args int 196 STD BSD { int getdirentries(int fd, char *buf, u_int count, \ long *basep); } 197 STD BSD { caddr_t mmap(caddr_t addr, size_t len, int prot, \ int flags, int fd, long pad, off_t pos); } 198 STD NOHIDE { int nosys(void); } __syscall __syscall_args int 199 STD POSIX { off_t lseek(int fd, int pad, off_t offset, \ int whence); } 200 STD BSD { int truncate(char *path, int pad, off_t length); } 201 STD BSD { int ftruncate(int fd, int pad, off_t length); } 202 STD BSD { int __sysctl(int *name, u_int namelen, void *old, \ size_t *oldlenp, void *new, size_t newlen); } \ __sysctl sysctl_args int ; properly, __sysctl should be a NOHIDE, but making an exception ; here allows to avoid one in libc/sys/Makefile.inc. 203 STD BSD { int mlock(caddr_t addr, size_t len); } 204 STD BSD { int munlock(caddr_t addr, size_t len); } 205 UNIMPL NOHIDE nosys 206 UNIMPL NOHIDE nosys 207 UNIMPL NOHIDE nosys 208 UNIMPL NOHIDE nosys 209 UNIMPL NOHIDE nosys ; ; The following are reserved for loadable syscalls ; 210 NODEF NOHIDE lkmnosys lkmnosys nosys_args int 211 NODEF NOHIDE lkmnosys lkmnosys nosys_args int 212 NODEF NOHIDE lkmnosys lkmnosys nosys_args int 213 NODEF NOHIDE lkmnosys lkmnosys nosys_args int 214 NODEF NOHIDE lkmnosys lkmnosys nosys_args int 215 NODEF NOHIDE lkmnosys lkmnosys nosys_args int 216 NODEF NOHIDE lkmnosys lkmnosys nosys_args int 217 NODEF NOHIDE lkmnosys lkmnosys nosys_args int 218 NODEF NOHIDE lkmnosys lkmnosys nosys_args int 219 NODEF NOHIDE lkmnosys lkmnosys nosys_args int ; ; The following were originally used in NetBSD. ; 220 STD BSD { int __semctl(int semid, int semnum, int cmd, \ union semun *arg); } 221 STD BSD { int semget(key_t key, int nsems, int semflg); } 222 STD BSD { int semop(int semid, struct sembuf *sops, \ u_int nsops); } 223 STD BSD { int semconfig(int flag); } 224 STD BSD { int msgctl(int msqid, int cmd, \ struct msqid_ds *buf); } 225 STD BSD { int msgget(key_t key, int msgflg); } 226 STD BSD { int msgsnd(int msqid, void *msgp, size_t msgsz, \ int msgflg); } 227 STD BSD { int msgrcv(int msqid, void *msgp, size_t msgsz, \ long msgtyp, int msgflg); } 228 STD BSD { int shmat(int shmid, void *shmaddr, int shmflg); } 229 STD BSD { int shmctl(int shmid, int cmd, \ struct shmid_ds *buf); } 230 STD BSD { int shmdt(void *shmaddr); } 231 STD BSD { int shmget(key_t key, int size, int shmflg); }