sys/kern/syscalls.master

   1  $DragonFly: src/sys/kern/syscalls.master,v 1.60 2008/11/10 22:11:45 pavalos Exp $
   2
   3 ; @(#)syscalls.master   8.2 (Berkeley) 1/13/94
   4 ; $FreeBSD: src/sys/kern/syscalls.master,v 1.72.2.10 2002/07/12 08:22:46 alfred Exp $
   5 ;
   6 ; System call name/number master file.
   7 ; Processed to created init_sysent.c, syscalls.c and syscall.h.
   8
   9 ; Columns: number [MPSAFE] type nargs namespc name alt{name,tag,rtyp}/comments
  10 ;       number  system call number, must be in order
  11 ;   MPSAFE      optional field, specifies that syscall does not want the
  12 ;               BGL grabbed automatically (it is SMP safe).
  13 ;       type    one of STD, OBSOL, UNIMPL, COMPAT, CPT_NOA, LIBCOMPAT,
  14 ;               NODEF, NOARGS, NOPROTO, NOIMPL
  15 ;       namespc one of POSIX, BSD, NOHIDE
  16 ;       name    psuedo-prototype of syscall routine
  17 ;               If one of the following alts is different, then all appear:
  18 ;       altname name of system call if different
  19 ;       alttag  name of args struct tag if different from [o]`name'"_args"
  20 ;       altrtyp return type if not int (bogus - syscalls always return int)
  21 ;               for UNIMPL/OBSOL, name continues with comments
  22
  23 ; types:
  24 ;       STD     always included
  25 ;       COMPAT  included on COMPAT #ifdef
  26 ;       LIBCOMPAT included on COMPAT #ifdef, and placed in syscall.h
  27 ;       OBSOL   obsolete, not included in system, only specifies name
  28 ;       UNIMPL  not implemented, placeholder only
  29
  30 ; #ifdef's, etc. may be included, and are copied to the output files.
  31
  32 #include <sys/param.h>
  33 #include <sys/sysent.h>
  34 #include <sys/sysproto.h>
  35 #include <sys/statvfs.h>
  36
  37 #ifdef COMPAT_43
  38 #include <emulation/43bsd/stat.h>
  39 #endif
  40
  41 #include <emulation/dragonfly12/stat.h>
  42
  43 ; Reserved/unimplemented system calls in the range 0-150 inclusive
  44 ; are reserved for use in future Berkeley releases.
  45 ; Additional system calls implemented in vendor and other
  46 ; redistributions should be placed in the reserved range at the end
  47 ; of the current calls.
  48
  49 0       STD     NOHIDE  { int nosys(void); } syscall nosys_args int
  50 1       STD     NOHIDE  { void exit(int rval); }
  51 2       STD     POSIX   { int fork(void); }
  52 3       MPSAFE  STD     POSIX   { ssize_t read(int fd, void *buf, size_t nbyte); }
  53 4       MPSAFE  STD     POSIX   { ssize_t write(int fd, const void *buf, size_t nbyte); }
  54 5       STD     POSIX   { int open(char *path, int flags, int mode); }
  55 ; XXX should be         { int open(const char *path, int flags, ...); }
  56 ; but we're not ready for `const' or varargs.
  57 ; XXX man page says `mode_t mode'.
  58 6       MPSAFE  STD     POSIX   { int close(int fd); }
  59 7       STD     BSD     { int wait4(int pid, int *status, int options, \
  60                             struct rusage *rusage); } wait4 wait_args int
  61 8       COMPAT  BSD     { int creat(char *path, int mode); }
  62 9       STD     POSIX   { int link(char *path, char *link); }
  63 10      STD     POSIX   { int unlink(char *path); }
  64 11      OBSOL   NOHIDE  execv
  65 12      STD     POSIX   { int chdir(char *path); }
  66 13      STD     BSD     { int fchdir(int fd); }
  67 14      STD     POSIX   { int mknod(char *path, int mode, int dev); }
  68 15      STD     POSIX   { int chmod(char *path, int mode); }
  69 16      STD     POSIX   { int chown(char *path, int uid, int gid); }
  70 17      STD     BSD     { int obreak(char *nsize); } break obreak_args int
  71 18      STD     BSD     { int getfsstat(struct statfs *buf, long bufsize, \
  72                             int flags); }
  73 19      COMPAT  POSIX   { long lseek(int fd, long offset, int whence); }
  74 20      STD     POSIX   { pid_t getpid(void); }
  75 21      STD     BSD     { int mount(char *type, char *path, int flags, \
  76                             caddr_t data); }
  77 ; XXX `path' should have type `const char *' but we're not ready for that.
  78 22      STD     BSD     { int unmount(char *path, int flags); }
  79 23      STD     POSIX   { int setuid(uid_t uid); }
  80 24      MPSAFE  STD     POSIX   { uid_t getuid(void); }
  81 25      MPSAFE  STD     POSIX   { uid_t geteuid(void); }
  82 26      STD     BSD     { int ptrace(int req, pid_t pid, caddr_t addr, \
  83                             int data); }
  84 27      STD     BSD     { int recvmsg(int s, struct msghdr *msg, int flags); }
  85 28      STD     BSD     { int sendmsg(int s, caddr_t msg, int flags); }
  86 29      STD     BSD     { int recvfrom(int s, caddr_t buf, size_t len, \
  87                             int flags, caddr_t from, int *fromlenaddr); }
  88 30      STD     BSD     { int accept(int s, caddr_t name, int *anamelen); }
  89 31      STD     BSD     { int getpeername(int fdes, caddr_t asa, int *alen); }
  90 32      STD     BSD     { int getsockname(int fdes, caddr_t asa, int *alen); }
  91 33      STD     POSIX   { int access(char *path, int flags); }
  92 34      STD     BSD     { int chflags(char *path, int flags); }
  93 35      STD     BSD     { int fchflags(int fd, int flags); }
  94 36      STD     BSD     { int sync(void); }
  95 37      STD     POSIX   { int kill(int pid, int signum); }
  96 38      COMPAT  POSIX   { int stat(char *path, struct ostat *ub); }
  97 39      STD     POSIX   { pid_t getppid(void); }
  98 40      COMPAT  POSIX   { int lstat(char *path, struct ostat *ub); }
  99 41      MPSAFE  STD     POSIX   { int dup(u_int fd); }
 100 42      STD     POSIX   { int pipe(void); }
 101 43      STD     POSIX   { gid_t getegid(void); }
 102 44      STD     BSD     { int profil(caddr_t samples, size_t size, \
 103                             size_t offset, u_int scale); }
 104 45      STD     BSD     { int ktrace(const char *fname, int ops, int facs, \
 105                             int pid); }
 106 46      OBSOL   NOHIDE  freebsd3_sigaction
 107 47      MPSAFE  STD     POSIX   { gid_t getgid(void); }
 108 48      OBSOL   NOHIDE  freebsd3_sigprocmask
 109 ; XXX note nonstandard (bogus) calling convention - the libc stub passes
 110 ; us the mask, not a pointer to it, and we return the old mask as the
 111 ; (int) return value.
 112 49      STD     BSD     { int getlogin(char *namebuf, u_int namelen); }
 113 50      STD     BSD     { int setlogin(char *namebuf); }
 114 51      STD     BSD     { int acct(char *path); }
 115 52      OBSOL   NOHIDE  freebsd3_sigpending
 116 53      STD     BSD     { int sigaltstack(stack_t *ss, stack_t *oss); }
 117 54      STD     POSIX   { int ioctl(int fd, u_long com, caddr_t data); }
 118 55      STD     BSD     { int reboot(int opt); }
 119 56      STD     POSIX   { int revoke(char *path); }
 120 57      STD     POSIX   { int symlink(char *path, char *link); }
 121 58      STD     POSIX   { int readlink(char *path, char *buf, int count); }
 122 59      STD     POSIX   { int execve(char *fname, char **argv, char **envv); }
 123 60      MPSAFE  STD     POSIX   { int umask(int newmask); } umask umask_args int
 124 61      STD     BSD     { int chroot(char *path); }
 125 62      COMPAT  POSIX   { int fstat(int fd, struct ostat *sb); }
 126 63      COMPAT  BSD     { int getkerninfo(int op, char *where, size_t *size, \
 127                             int arg); } getkerninfo getkerninfo_args int
 128 64      COMPAT  BSD     { int getpagesize(void); } \
 129                             getpagesize getpagesize_args int
 130 65      STD     BSD     { int msync(void *addr, size_t len, int flags); }
 131 66      STD     BSD     { int vfork(void); }
 132 67      OBSOL   NOHIDE  vread
 133 68      OBSOL   NOHIDE  vwrite
 134 69      STD     BSD     { int sbrk(int incr); }
 135 70      STD     BSD     { int sstk(int incr); }
 136 71      COMPAT  BSD     { int mmap(void *addr, int len, int prot, \
 137                             int flags, int fd, long pos); }
 138 72      STD     BSD     { int ovadvise(int anom); } vadvise ovadvise_args int
 139 73      STD     BSD     { int munmap(void *addr, size_t len); }
 140 74      STD     BSD     { int mprotect(const void *addr, size_t len, int prot); }
 141 75      STD     BSD     { int madvise(void *addr, size_t len, int behav); }
 142 76      OBSOL   NOHIDE  vhangup
 143 77      OBSOL   NOHIDE  vlimit
 144 78      STD     BSD     { int mincore(const void *addr, size_t len, \
 145                             char *vec); }
 146 79      STD     POSIX   { int getgroups(u_int gidsetsize, gid_t *gidset); }
 147 80      STD     POSIX   { int setgroups(u_int gidsetsize, gid_t *gidset); }
 148 81      MPSAFE  STD     POSIX   { int getpgrp(void); }
 149 82      STD     POSIX   { int setpgid(int pid, int pgid); }
 150 83      STD     BSD     { int setitimer(u_int which, struct itimerval *itv, \
 151                             struct itimerval *oitv); }
 152 84      COMPAT  BSD     { int wait(void); }
 153 85      STD     BSD     { int swapon(char *name); }
 154 86      STD     BSD     { int getitimer(u_int which, struct itimerval *itv); }
 155 87      COMPAT  BSD     { int gethostname(char *hostname, u_int len); } \
 156                             gethostname gethostname_args int
 157 88      COMPAT  BSD     { int sethostname(char *hostname, u_int len); } \
 158                             sethostname sethostname_args int
 159 89      MPSAFE  STD     BSD     { int getdtablesize(void); }
 160 90      MPSAFE  STD     POSIX   { int dup2(u_int from, u_int to); }
 161 91      UNIMPL  BSD     getdopt
 162 92      MPSAFE  STD     POSIX   { int fcntl(int fd, int cmd, long arg); }
 163 ; XXX should be         { int fcntl(int fd, int cmd, ...); }
 164 ; but we're not ready for varargs.
 165 ; XXX man page says `int arg' too.
 166 93      STD     BSD     { int select(int nd, fd_set *in, fd_set *ou, \
 167                             fd_set *ex, struct timeval *tv); }
 168 94      UNIMPL  BSD     setdopt
 169 95      STD     POSIX   { int fsync(int fd); }
 170 96      STD     BSD     { int setpriority(int which, int who, int prio); }
 171 97      STD     BSD     { int socket(int domain, int type, int protocol); }
 172 98      STD     BSD     { int connect(int s, caddr_t name, int namelen); }
 173 99      CPT_NOA BSD     { int accept(int s, caddr_t name, int *anamelen); } \
 174                             accept accept_args int
 175 100     STD     BSD     { int getpriority(int which, int who); }
 176 101     COMPAT  BSD     { int send(int s, caddr_t buf, int len, int flags); }
 177 102     COMPAT  BSD     { int recv(int s, caddr_t buf, int len, int flags); }
 178 103     OBSOL   NOHIDE  freebsd3_sigreturn
 179 104     STD     BSD     { int bind(int s, caddr_t name, int namelen); }
 180 105     STD     BSD     { int setsockopt(int s, int level, int name, \
 181                             caddr_t val, int valsize); }
 182 106     STD     BSD     { int listen(int s, int backlog); }
 183 107     OBSOL   NOHIDE  vtimes
 184 108     COMPAT  BSD     { int sigvec(int signum, struct sigvec *nsv, \
 185                             struct sigvec *osv); }
 186 109     COMPAT  BSD     { int sigblock(int mask); }
 187 110     COMPAT  BSD     { int sigsetmask(int mask); }
 188 111     OBSOL   NOHIDE  freebsd3_sigsuspend
 189 ; XXX note nonstandard (bogus) calling convention - the libc stub passes
 190 ; us the mask, not a pointer to it.
 191 112     COMPAT  BSD     { int sigstack(struct sigstack *nss, \
 192                             struct sigstack *oss); }
 193 113     COMPAT  BSD     { int recvmsg(int s, struct omsghdr *msg, int flags); }
 194 114     COMPAT  BSD     { int sendmsg(int s, caddr_t msg, int flags); }
 195 115     OBSOL   NOHIDE  vtrace
 196 116     MPSAFE  STD     BSD     { int gettimeofday(struct timeval *tp, \
 197                             struct timezone *tzp); }
 198 117     STD     BSD     { int getrusage(int who, struct rusage *rusage); }
 199 118     STD     BSD     { int getsockopt(int s, int level, int name, \
 200                             caddr_t val, int *avalsize); }
 201 119     UNIMPL  NOHIDE  resuba (BSD/OS 2.x)
 202 120     MPSAFE  STD     BSD     { int readv(int fd, struct iovec *iovp, u_int iovcnt); }
 203 121     MPSAFE  STD     BSD     { int writev(int fd, struct iovec *iovp, \
 204                             u_int iovcnt); }
 205 122     STD     BSD     { int settimeofday(struct timeval *tv, \
 206                             struct timezone *tzp); }
 207 123     STD     BSD     { int fchown(int fd, int uid, int gid); }
 208 124     STD     BSD     { int fchmod(int fd, int mode); }
 209 125     CPT_NOA BSD     { int recvfrom(int s, caddr_t buf, size_t len, \
 210                             int flags, caddr_t from, int *fromlenaddr); } \
 211                             recvfrom recvfrom_args int
 212 126     STD     BSD     { int setreuid(int ruid, int euid); }
 213 127     STD     BSD     { int setregid(int rgid, int egid); }
 214 128     STD     POSIX   { int rename(char *from, char *to); }
 215 129     COMPAT  BSD     { int truncate(char *path, long length); }
 216 130     COMPAT  BSD     { int ftruncate(int fd, long length); }
 217 131     STD     BSD     { int flock(int fd, int how); }
 218 132     STD     POSIX   { int mkfifo(char *path, int mode); }
 219 133     STD     BSD     { int sendto(int s, caddr_t buf, size_t len, \
 220                             int flags, caddr_t to, int tolen); }
 221 134     STD     BSD     { int shutdown(int s, int how); }
 222 135     STD     BSD     { int socketpair(int domain, int type, int protocol, \
 223                             int *rsv); }
 224 136     STD     POSIX   { int mkdir(char *path, int mode); }
 225 137     STD     POSIX   { int rmdir(char *path); }
 226 138     STD     BSD     { int utimes(char *path, struct timeval *tptr); }
 227 139     OBSOL   NOHIDE  4.2 sigreturn
 228 140     STD     BSD     { int adjtime(struct timeval *delta, \
 229                             struct timeval *olddelta); }
 230 141     COMPAT  BSD     { int getpeername(int fdes, caddr_t asa, int *alen); }
 231 142     COMPAT  BSD     { long gethostid(void); }
 232 143     COMPAT  BSD     { int sethostid(long hostid); }
 233 144     MPSAFE  COMPAT  BSD     { int getrlimit(u_int which, struct orlimit *rlp); }
 234 145     MPSAFE  COMPAT  BSD     { int setrlimit(u_int which, struct orlimit *rlp); }
 235 146     COMPAT  BSD     { int killpg(int pgid, int signum); }
 236 147     STD     POSIX   { int setsid(void); }
 237 148     STD     BSD     { int quotactl(char *path, int cmd, int uid, \
 238                             caddr_t arg); }
 239 149     COMPAT  BSD     { int quota(void); }
 240 150     CPT_NOA BSD     { int getsockname(int fdec, caddr_t asa, int *alen); }\
 241                             getsockname getsockname_args int
 242
 243 ; Syscalls 151-180 inclusive are reserved for vendor-specific
 244 ; system calls.  (This includes various calls added for compatibity
 245 ; with other Unix variants.)
 246 ; Some of these calls are now supported by BSD...
 247 151     UNIMPL  NOHIDE  sem_lock (BSD/OS 2.x)
 248 152     UNIMPL  NOHIDE  sem_wakeup (BSD/OS 2.x)
 249 153     UNIMPL  NOHIDE  asyncdaemon (BSD/OS 2.x)
 250 154     UNIMPL  NOHIDE  nosys
 251 ; 155 is initialized by the NFS code, if present.
 252 155     NOIMPL  BSD     { int nfssvc(int flag, caddr_t argp); }
 253 156     COMPAT  BSD     { int getdirentries(int fd, char *buf, u_int count, \
 254                             long *basep); }
 255 157     STD     BSD     { int statfs(char *path, struct statfs *buf); }
 256 158     STD     BSD     { int fstatfs(int fd, struct statfs *buf); }
 257 159     UNIMPL  NOHIDE  nosys
 258 160     UNIMPL  NOHIDE  nosys
 259 ; 161 is initialized by the NFS code, if present.
 260 161     STD     BSD     { int getfh(char *fname, struct fhandle *fhp); }
 261 162     STD     BSD     { int getdomainname(char *domainname, int len); }
 262 163     STD     BSD     { int setdomainname(char *domainname, int len); }
 263 164     STD     BSD     { int uname(struct utsname *name); }
 264 165     STD     BSD     { int sysarch(int op, char *parms); }
 265 166     STD     BSD     { int rtprio(int function, pid_t pid, \
 266                             struct rtprio *rtp); }
 267 167     UNIMPL  NOHIDE  nosys
 268 168     UNIMPL  NOHIDE  nosys
 269 169     STD     BSD     { int semsys(int which, int a2, int a3, int a4, \
 270                             int a5); }
 271 ; XXX should be         { int semsys(int which, ...); }
 272 170     STD     BSD     { int msgsys(int which, int a2, int a3, int a4, \
 273                             int a5, int a6); }
 274 ; XXX should be         { int msgsys(int which, ...); }
 275 171     STD     BSD     { int shmsys(int which, int a2, int a3, int a4); }
 276 ; XXX should be         { int shmsys(int which, ...); }
 277 172     UNIMPL  NOHIDE  nosys
 278 173     MPSAFE  STD     POSIX   { ssize_t extpread(int fd, void *buf, \
 279                             size_t nbyte, int flags, off_t offset); }
 280 174     MPSAFE  STD     POSIX   { ssize_t extpwrite(int fd, const void *buf, \
 281                             size_t nbyte, int flags, off_t offset); }
 282 175     UNIMPL  NOHIDE  nosys
 283 176     STD     BSD     { int ntp_adjtime(struct timex *tp); }
 284 177     UNIMPL  NOHIDE  sfork (BSD/OS 2.x)
 285 178     UNIMPL  NOHIDE  getdescriptor (BSD/OS 2.x)
 286 179     UNIMPL  NOHIDE  setdescriptor (BSD/OS 2.x)
 287 180     UNIMPL  NOHIDE  nosys
 288
 289 ; Syscalls 181-199 are used by/reserved for BSD
 290 181     STD     POSIX   { int setgid(gid_t gid); }
 291 182     STD     BSD     { int setegid(gid_t egid); }
 292 183     STD     BSD     { int seteuid(uid_t euid); }
 293 184     UNIMPL  BSD     lfs_bmapv
 294 185     UNIMPL  BSD     lfs_markv
 295 186     UNIMPL  BSD     lfs_segclean
 296 187     UNIMPL  BSD     lfs_segwait
 297 188     COMPAT_DF12     POSIX   { int stat(const char *path, struct dfbsd12_stat *ub); }
 298 189     COMPAT_DF12     POSIX   { int fstat(int fd, struct dfbsd12_stat *sb); }
 299 190     COMPAT_DF12     POSIX   { int lstat(const char *path, struct dfbsd12_stat *ub); }
 300 191     STD     POSIX   { int pathconf(char *path, int name); }
 301 192     STD     POSIX   { int fpathconf(int fd, int name); }
 302 193     UNIMPL  NOHIDE  nosys
 303 194     STD     BSD     { int getrlimit(u_int which, \
 304                             struct rlimit *rlp); } \
 305                             getrlimit __getrlimit_args int
 306 195     STD     BSD     { int setrlimit(u_int which, \
 307                             struct rlimit *rlp); } \
 308                             setrlimit __setrlimit_args int
 309 196     COMPAT_DF12     BSD     { int getdirentries(int fd, char *buf, \
 310                                     u_int count, long *basep); }
 311 197     STD     BSD     { caddr_t mmap(caddr_t addr, size_t len, int prot, \
 312                             int flags, int fd, int pad, off_t pos); }
 313 198     STD     NOHIDE  { int nosys(void); } __syscall __syscall_args int
 314 199     STD     POSIX   { off_t lseek(int fd, int pad, off_t offset, \
 315                             int whence); }
 316 200     STD     BSD     { int truncate(char *path, int pad, off_t length); }
 317 201     STD     BSD     { int ftruncate(int fd, int pad, off_t length); }
 318 202     STD     BSD     { int __sysctl(int *name, u_int namelen, void *old, \
 319                             size_t *oldlenp, void *new, size_t newlen); } \
 320                             __sysctl sysctl_args int
 321 ; properly, __sysctl should be a NOHIDE, but making an exception
 322 ; here allows to avoid one in libc/sys/Makefile.inc.
 323 203     STD     BSD     { int mlock(const void *addr, size_t len); }
 324 204     STD     BSD     { int munlock(const void *addr, size_t len); }
 325 205     STD     BSD     { int undelete(char *path); }
 326 206     STD     BSD     { int futimes(int fd, struct timeval *tptr); }
 327 207     STD     BSD     { int getpgid(pid_t pid); }
 328 208     UNIMPL  NOHIDE  newreboot (NetBSD)
 329 209     STD     BSD     { int poll(struct pollfd *fds, u_int nfds, \
 330                             int timeout); }
 331
 332 ;
 333 ; The following are reserved for loadable syscalls
 334 ;
 335 ; 210 is used by the Checkpoint Module
 336 210     NODEF   NOHIDE  lkmnosys lkmnosys nosys_args int
 337 211     NODEF   NOHIDE  lkmnosys lkmnosys nosys_args int
 338 212     NODEF   NOHIDE  lkmnosys lkmnosys nosys_args int
 339 213     NODEF   NOHIDE  lkmnosys lkmnosys nosys_args int
 340 214     NODEF   NOHIDE  lkmnosys lkmnosys nosys_args int
 341 215     NODEF   NOHIDE  lkmnosys lkmnosys nosys_args int
 342 216     NODEF   NOHIDE  lkmnosys lkmnosys nosys_args int
 343 217     NODEF   NOHIDE  lkmnosys lkmnosys nosys_args int
 344 218     NODEF   NOHIDE  lkmnosys lkmnosys nosys_args int
 345 219     NODEF   NOHIDE  lkmnosys lkmnosys nosys_args int
 346
 347 ;
 348 ; The following were introduced with NetBSD/4.4Lite-2
 349 ;
 350 220     STD     BSD     { int __semctl(int semid, int semnum, int cmd, \
 351                             union semun *arg); }
 352 221     STD     BSD     { int semget(key_t key, int nsems, int semflg); }
 353 222     STD     BSD     { int semop(int semid, struct sembuf *sops, \
 354                             u_int nsops); }
 355 223     UNIMPL  NOHIDE  semconfig
 356 224     STD     BSD     { int msgctl(int msqid, int cmd, \
 357                             struct msqid_ds *buf); }
 358 225     STD     BSD     { int msgget(key_t key, int msgflg); }
 359 226     STD     BSD     { int msgsnd(int msqid, void *msgp, size_t msgsz, \
 360                             int msgflg); }
 361 227     STD     BSD     { int msgrcv(int msqid, void *msgp, size_t msgsz, \
 362                             long msgtyp, int msgflg); }
 363 228     STD     BSD     { int shmat(int shmid, void *shmaddr, int shmflg); }
 364 229     STD     BSD     { int shmctl(int shmid, int cmd, \
 365                             struct shmid_ds *buf); }
 366 230     STD     BSD     { int shmdt(void *shmaddr); }
 367 231     STD     BSD     { int shmget(key_t key, int size, int shmflg); }
 368 ;
 369 232     STD     POSIX   { int clock_gettime(clockid_t clock_id, \
 370                             struct timespec *tp); }
 371 233     STD     POSIX   { int clock_settime(clockid_t clock_id, \
 372                             const struct timespec *tp); }
 373 234     STD     POSIX   { int clock_getres(clockid_t clock_id, \
 374                             struct timespec *tp); }
 375 235     UNIMPL  NOHIDE  timer_create
 376 236     UNIMPL  NOHIDE  timer_delete
 377 237     UNIMPL  NOHIDE  timer_settime
 378 238     UNIMPL  NOHIDE  timer_gettime
 379 239     UNIMPL  NOHIDE  timer_getoverrun
 380 240     STD     POSIX   { int nanosleep(const struct timespec *rqtp, \
 381                             struct timespec *rmtp); }
 382 241     UNIMPL  NOHIDE  nosys
 383 242     UNIMPL  NOHIDE  nosys
 384 243     UNIMPL  NOHIDE  nosys
 385 244     UNIMPL  NOHIDE  nosys
 386 245     UNIMPL  NOHIDE  nosys
 387 246     UNIMPL  NOHIDE  nosys
 388 247     UNIMPL  NOHIDE  nosys
 389 248     UNIMPL  NOHIDE  nosys
 390 249     UNIMPL  NOHIDE  nosys
 391 ; syscall numbers initially used in OpenBSD
 392 250     STD     BSD     { int minherit(void *addr, size_t len, int inherit); }
 393 251     STD     BSD     { int rfork(int flags); }
 394 252     STD     BSD     { int openbsd_poll(struct pollfd *fds, u_int nfds, \
 395                             int timeout); }
 396 253     STD     BSD     { int issetugid(void); }
 397 254     STD     BSD     { int lchown(char *path, int uid, int gid); }
 398 255     UNIMPL  NOHIDE  nosys
 399 256     UNIMPL  NOHIDE  nosys
 400 257     UNIMPL  NOHIDE  nosys
 401 258     UNIMPL  NOHIDE  nosys
 402 259     UNIMPL  NOHIDE  nosys
 403 260     UNIMPL  NOHIDE  nosys
 404 261     UNIMPL  NOHIDE  nosys
 405 262     UNIMPL  NOHIDE  nosys
 406 263     UNIMPL  NOHIDE  nosys
 407 264     UNIMPL  NOHIDE  nosys
 408 265     UNIMPL  NOHIDE  nosys
 409 266     UNIMPL  NOHIDE  nosys
 410 267     UNIMPL  NOHIDE  nosys
 411 268     UNIMPL  NOHIDE  nosys
 412 269     UNIMPL  NOHIDE  nosys
 413 270     UNIMPL  NOHIDE  nosys
 414 271     UNIMPL  NOHIDE  nosys
 415 272     COMPAT_DF12     BSD     { int getdents(int fd, char *buf, size_t count); }
 416 273     UNIMPL  NOHIDE  nosys
 417 274     STD     BSD     { int lchmod(char *path, mode_t mode); }
 418 275     NOPROTO BSD     { int lchown(char *path, uid_t uid, gid_t gid); } netbsd_lchown lchown_args int
 419 276     STD     BSD     { int lutimes(char *path, struct timeval *tptr); }
 420 277     NOPROTO BSD     { int msync(void *addr, size_t len, int flags); } netbsd_msync msync_args int
 421 278     OBSOL   BSD     { int nstat(char *path, struct nstat *ub); }
 422 279     OBSOL   NOHIDE  { int nfstat(int fd, struct nstat *sb); }
 423 280     OBSOL   NOHIDE  { int nlstat(char *path, struct nstat *ub); }
 424 281     UNIMPL  NOHIDE  nosys
 425 282     UNIMPL  NOHIDE  nosys
 426 283     UNIMPL  NOHIDE  nosys
 427 284     UNIMPL  NOHIDE  nosys
 428 285     UNIMPL  NOHIDE  nosys
 429 286     UNIMPL  NOHIDE  nosys
 430 287     UNIMPL  NOHIDE  nosys
 431 288     UNIMPL  NOHIDE  nosys
 432 ; 289 and 290 from NetBSD (OpenBSD: 267 and 268)
 433 289     MPSAFE  STD     BSD     { ssize_t extpreadv(int fd, struct iovec *iovp, \
 434                                   u_int iovcnt, int flags, off_t offset); }
 435 290     MPSAFE  STD     BSD     { ssize_t extpwritev(int fd, struct iovec *iovp,\
 436                                   u_int iovcnt, int flags, off_t offset); }
 437 291     UNIMPL  NOHIDE  nosys
 438 292     UNIMPL  NOHIDE  nosys
 439 293     UNIMPL  NOHIDE  nosys
 440 294     UNIMPL  NOHIDE  nosys
 441 295     UNIMPL  NOHIDE  nosys
 442 296     UNIMPL  NOHIDE  nosys
 443 ; XXX 297 is 300 in NetBSD
 444 297     STD     BSD     { int fhstatfs(const struct fhandle *u_fhp, struct statfs *buf); }
 445 298     STD     BSD     { int fhopen(const struct fhandle *u_fhp, int flags); }
 446 299     COMPAT_DF12     POSIX   { int fhstat(const struct fhandle *u_fhp, struct dfbsd12_stat *sb); }
 447 ; syscall numbers for FreeBSD
 448 300     STD     BSD     { int modnext(int modid); }
 449 301     STD     BSD     { int modstat(int modid, struct module_stat* stat); }
 450 302     STD     BSD     { int modfnext(int modid); }
 451 303     STD     BSD     { int modfind(const char *name); }
 452 304     STD     BSD     { int kldload(const char *file); }
 453 305     STD     BSD     { int kldunload(int fileid); }
 454 306     STD     BSD     { int kldfind(const char *file); }
 455 307     STD     BSD     { int kldnext(int fileid); }
 456 308     STD     BSD     { int kldstat(int fileid, struct kld_file_stat* stat); }
 457 309     STD     BSD     { int kldfirstmod(int fileid); }
 458 310     STD     BSD     { int getsid(pid_t pid); }
 459 311     STD     BSD     { int setresuid(uid_t ruid, uid_t euid, uid_t suid); }
 460 312     STD     BSD     { int setresgid(gid_t rgid, gid_t egid, gid_t sgid); }
 461 313     OBSOL   NOHIDE  signanosleep
 462 314     STD     BSD     { int aio_return(struct aiocb *aiocbp); }
 463 315     STD     BSD     { int aio_suspend(struct aiocb * const * aiocbp, int nent, const struct timespec *timeout); }
 464 316     STD     BSD     { int aio_cancel(int fd, struct aiocb *aiocbp); }
 465 317     STD     BSD     { int aio_error(struct aiocb *aiocbp); }
 466 318     STD     BSD     { int aio_read(struct aiocb *aiocbp); }
 467 319     STD     BSD     { int aio_write(struct aiocb *aiocbp); }
 468 320     STD     BSD     { int lio_listio(int mode, struct aiocb * const *acb_list, int nent, struct sigevent *sig); }
 469 321     STD     BSD     { int yield(void); }
 470 322     STD     BSD     { int thr_sleep(const struct timespec *timeout); }
 471 323     STD     BSD     { int thr_wakeup(pid_t pid); }
 472 324     STD     BSD     { int mlockall(int how); }
 473 325     STD     BSD     { int munlockall(void); }
 474 326     STD     BSD     { int __getcwd(u_char *buf, u_int buflen); }
 475
 476 327     STD     POSIX   { int sched_setparam (pid_t pid, const struct sched_param *param); }
 477 328     STD     POSIX   { int sched_getparam (pid_t pid, struct sched_param *param); }
 478
 479 329     STD     POSIX   { int sched_setscheduler (pid_t pid, int policy, const struct sched_param *param); }
 480 330     STD     POSIX   { int sched_getscheduler (pid_t pid); }
 481
 482 331     STD     POSIX   { int sched_yield (void); }
 483 332     STD     POSIX   { int sched_get_priority_max (int policy); }
 484 333     STD     POSIX   { int sched_get_priority_min (int policy); }
 485 334     STD     POSIX   { int sched_rr_get_interval (pid_t pid, struct timespec *interval); }
 486 335     STD     BSD     { int utrace(const void *addr, size_t len); }
 487 336     OBSOL   NOHIDE  freebsd4_sendfile
 488 337     STD     BSD     { int kldsym(int fileid, int cmd, void *data); }
 489 338     STD     BSD     { int jail(struct jail *jail); }
 490 339     UNIMPL  BSD     pioctl
 491 340     MPSAFE  STD     POSIX   { int sigprocmask(int how, const sigset_t *set, \
 492                             sigset_t *oset); }
 493 341     STD     POSIX   { int sigsuspend(const sigset_t *sigmask); }
 494 342     STD     POSIX   { int sigaction(int sig, const struct sigaction *act, \
 495                             struct sigaction *oact); }
 496 343     STD     POSIX   { int sigpending(sigset_t *set); }
 497 344     STD     BSD     { int sigreturn(ucontext_t *sigcntxp); }
 498 345     STD     POSIX   { int sigtimedwait(const sigset_t *set,\
 499                              siginfo_t *info, const struct timespec *timeout); }
 500 346     STD     POSIX   { int sigwaitinfo(const sigset_t *set,\
 501                              siginfo_t *info); }
 502 347     STD     BSD     { int __acl_get_file(const char *path, \
 503                             acl_type_t type, struct acl *aclp); }
 504 348     STD     BSD     { int __acl_set_file(const char *path, \
 505                             acl_type_t type, struct acl *aclp); }
 506 349     STD     BSD     { int __acl_get_fd(int filedes, acl_type_t type, \
 507                             struct acl *aclp); }
 508 350     STD     BSD     { int __acl_set_fd(int filedes, acl_type_t type, \
 509                             struct acl *aclp); }
 510 351     STD     BSD     { int __acl_delete_file(const char *path, \
 511                             acl_type_t type); }
 512 352     STD     BSD     { int __acl_delete_fd(int filedes, acl_type_t type); }
 513 353     STD     BSD     { int __acl_aclcheck_file(const char *path, \
 514                             acl_type_t type, struct acl *aclp); }
 515 354     STD     BSD     { int __acl_aclcheck_fd(int filedes, acl_type_t type, \
 516                             struct acl *aclp); }
 517 355     STD     BSD     { int extattrctl(const char *path, int cmd, \
 518                             const char *attrname, char *arg); }
 519 356     STD     BSD     { int extattr_set_file(const char *path, \
 520                             const char *attrname, struct iovec *iovp, \
 521                             unsigned iovcnt); }
 522 357     STD     BSD     { int extattr_get_file(const char *path, \
 523                             const char *attrname, struct iovec *iovp, \
 524                             unsigned iovcnt); }
 525 358     STD     BSD     { int extattr_delete_file(const char *path, \
 526                             const char *attrname); }
 527 359     STD     BSD     { int aio_waitcomplete(struct aiocb **aiocbp, struct timespec *timeout); }
 528 360     STD     BSD     { int getresuid(uid_t *ruid, uid_t *euid, uid_t *suid); }
 529 361     STD     BSD     { int getresgid(gid_t *rgid, gid_t *egid, gid_t *sgid); }
 530 362     STD     BSD     { int kqueue(void); }
 531 363     STD     BSD     { int kevent(int fd, \
 532                             const struct kevent *changelist, int nchanges, \
 533                             struct kevent *eventlist, int nevents, \
 534                             const struct timespec *timeout); }
 535 364     STD     BSD     { int sctp_peeloff(int sd, caddr_t name ); }
 536 ; 365-392 used by FreeBSD-current
 537 365     UNIMPL  NOHIDE  nosys
 538 366     UNIMPL  NOHIDE  nosys
 539 367     UNIMPL  NOHIDE  nosys
 540 368     UNIMPL  NOHIDE  nosys
 541 369     UNIMPL  NOHIDE  nosys
 542 370     UNIMPL  NOHIDE  nosys
 543 371     UNIMPL  NOHIDE  nosys
 544 372     UNIMPL  NOHIDE  nosys
 545 373     UNIMPL  NOHIDE  nosys
 546 374     UNIMPL  NOHIDE  nosys
 547 375     UNIMPL  NOHIDE  nosys
 548 376     UNIMPL  NOHIDE  nosys
 549 377     UNIMPL  NOHIDE  nosys
 550 378     UNIMPL  NOHIDE  nosys
 551 379     UNIMPL  NOHIDE  nosys
 552 380     UNIMPL  NOHIDE  nosys
 553 381     UNIMPL  NOHIDE  nosys
 554 382     UNIMPL  NOHIDE  nosys
 555 383     UNIMPL  NOHIDE  nosys
 556 384     UNIMPL  NOHIDE  nosys
 557 385     UNIMPL  NOHIDE  nosys
 558 386     UNIMPL  NOHIDE  nosys
 559 387     UNIMPL  NOHIDE  nosys
 560 388     UNIMPL  NOHIDE  nosys
 561 389     UNIMPL  NOHIDE  nosys
 562 390     UNIMPL  NOHIDE  nosys
 563 391     STD     BSD     { int lchflags(char *path, int flags); }
 564 392     STD     BSD     { int uuidgen(struct uuid *store, int count); }
 565 393     STD     BSD     { int sendfile(int fd, int s, off_t offset, size_t nbytes, \
 566                                 struct sf_hdtr *hdtr, off_t *sbytes, int flags); }
 567 ; 394-439 used by FreeBSD-current
 568 394     UNIMPL  NOHIDE  nosys
 569 395     UNIMPL  NOHIDE  nosys
 570 396     UNIMPL  NOHIDE  nosys
 571 397     UNIMPL  NOHIDE  nosys
 572 398     UNIMPL  NOHIDE  nosys
 573 399     UNIMPL  NOHIDE  nosys
 574 400     UNIMPL  NOHIDE  nosys
 575 401     UNIMPL  NOHIDE  nosys
 576 402     UNIMPL  NOHIDE  nosys
 577 403     UNIMPL  NOHIDE  nosys
 578 404     UNIMPL  NOHIDE  nosys
 579 405     UNIMPL  NOHIDE  nosys
 580 406     UNIMPL  NOHIDE  nosys
 581 407     UNIMPL  NOHIDE  nosys
 582 408     UNIMPL  NOHIDE  nosys
 583 409     UNIMPL  NOHIDE  nosys
 584 410     UNIMPL  NOHIDE  nosys
 585 411     UNIMPL  NOHIDE  nosys
 586 412     UNIMPL  NOHIDE  nosys
 587 413     UNIMPL  NOHIDE  nosys
 588 414     UNIMPL  NOHIDE  nosys
 589 415     UNIMPL  NOHIDE  nosys
 590 416     UNIMPL  NOHIDE  nosys
 591 417     UNIMPL  NOHIDE  nosys
 592 418     UNIMPL  NOHIDE  nosys
 593 419     UNIMPL  NOHIDE  nosys
 594 420     UNIMPL  NOHIDE  nosys
 595 421     UNIMPL  NOHIDE  nosys
 596 422     UNIMPL  NOHIDE  nosys
 597 423     UNIMPL  NOHIDE  nosys
 598 424     UNIMPL  NOHIDE  nosys
 599 425     UNIMPL  NOHIDE  nosys
 600 426     UNIMPL  NOHIDE  nosys
 601 427     UNIMPL  NOHIDE  nosys
 602 428     UNIMPL  NOHIDE  nosys
 603 429     UNIMPL  NOHIDE  nosys
 604 430     UNIMPL  NOHIDE  nosys
 605 431     UNIMPL  NOHIDE  nosys
 606 432     UNIMPL  NOHIDE  nosys
 607 433     UNIMPL  NOHIDE  nosys
 608 434     UNIMPL  NOHIDE  nosys
 609 435     UNIMPL  NOHIDE  nosys
 610 436     UNIMPL  NOHIDE  nosys
 611 437     UNIMPL  NOHIDE  nosys
 612 438     UNIMPL  NOHIDE  nosys
 613 439     UNIMPL  NOHIDE  nosys
 614 ; 440-449 reserved for FreeBSD-5.x growth
 615 440     UNIMPL  NOHIDE  nosys
 616 441     UNIMPL  NOHIDE  nosys
 617 442     UNIMPL  NOHIDE  nosys
 618 443     UNIMPL  NOHIDE  nosys
 619 444     UNIMPL  NOHIDE  nosys
 620 445     UNIMPL  NOHIDE  nosys
 621 446     UNIMPL  NOHIDE  nosys
 622 447     UNIMPL  NOHIDE  nosys
 623 448     UNIMPL  NOHIDE  nosys
 624 449     UNIMPL  NOHIDE  nosys
 625 ; 450 DragonFly system calls
 626 450     STD     BSD     { int varsym_set(int level, const char *name, const char *data); }
 627 451     STD     BSD     { int varsym_get(int mask, const char *wild, char *buf, int bufsize); }
 628 452     STD     BSD     { int varsym_list(int level, char *buf, int maxsize, int *marker); }
 629 453     STD     BSD     { int upc_register(struct upcall *upc, void *ctxfunc, void *func, void *data); }
 630 454     STD     BSD     { int upc_control(int cmd, int upcid, void *data); }
 631 455     STD     BSD     { int caps_sys_service(const char *name, uid_t uid, gid_t gid, int upcid, int flags); }
 632 456     STD     BSD     { int caps_sys_client(const char *name, uid_t uid, gid_t gid, int upcid, int flags); }
 633 457     STD     BSD     { int caps_sys_close(int portid); }
 634 458     STD     BSD     { off_t caps_sys_put(int portid, void *msg, int msgsize); }
 635 459     STD     BSD     { int caps_sys_reply(int portid, void *msg, int msgsize, off_t msgcid); }
 636 460     STD     BSD     { int caps_sys_get(int portid, void *msg, int maxsize, struct caps_msgid *msgid, struct caps_cred *ccr); }
 637 461     STD     BSD     { int caps_sys_wait(int portid, void *msg, int maxsize, struct caps_msgid *msgid, struct caps_cred *ccr); }
 638 462     STD     BSD     { int caps_sys_abort(int portid, off_t msgcid, int flags); }
 639 463     STD     BSD     { off_t caps_sys_getgen(int portid); }
 640 464     STD     BSD     { int caps_sys_setgen(int portid, off_t gen); }
 641 465     STD     BSD     { int exec_sys_register(void *entry); }
 642 466     STD     BSD     { int exec_sys_unregister(int id); }
 643 467     STD     BSD     { int sys_checkpoint(int type, int fd, pid_t pid, int retval); }
 644 468     STD     BSD     { int mountctl(const char *path, int op, int fd, const void *ctl, int ctllen, void *buf, int buflen); }
 645 469     STD     BSD     { int umtx_sleep(volatile const int *ptr, int value, int timeout); }
 646 470     STD     BSD     { int umtx_wakeup(volatile const int *ptr, int count); }
 647 471     STD     BSD     { int jail_attach(int jid); }
 648 472     STD     BSD     { int set_tls_area(int which, struct tls_info *info, size_t infosize); }
 649 473     STD     BSD     { int get_tls_area(int which, struct tls_info *info, size_t infosize); }
 650 474     MPSAFE  STD     BSD     { int closefrom(int fd); }
 651 475     STD     POSIX   { int stat(const char *path, struct stat *ub); }
 652 476     STD     POSIX   { int fstat(int fd, struct stat *sb); }
 653 477     STD     POSIX   { int lstat(const char *path, struct stat *ub); }
 654 478     STD     BSD     { int fhstat(const struct fhandle *u_fhp, struct stat *sb); }
 655 479     STD     BSD     { int getdirentries(int fd, char *buf, u_int count, \
 656                             long *basep); }
 657 480     STD     BSD     { int getdents(int fd, char *buf, size_t count); }
 658 481     STD     BSD     { int usched_set(pid_t pid, int cmd, void *data, \
 659                                 int bytes); }
 660 482     STD     BSD     { int extaccept(int s, int flags, caddr_t name, int *anamelen); }
 661 483     STD     BSD     { int extconnect(int s, int flags, caddr_t name, int namelen); }
 662 484     STD     BSD     { int syslink(int cmd, struct syslink_info *info, size_t bytes); }
 663 485     STD     BSD     { int mcontrol(void *addr, size_t len, int behav, off_t value); }
 664 486     STD     BSD     { int vmspace_create(void *id, int type, void *data); }
 665 487     STD     BSD     { int vmspace_destroy(void *id); }
 666 488     STD     BSD     { int vmspace_ctl(void *id, int cmd,            \
 667                                           struct trapframe *tframe,     \
 668                                           struct vextframe *vframe); }
 669 489     STD     BSD     { int vmspace_mmap(void *id, void *addr, size_t len, \
 670                                           int prot, int flags, int fd, \
 671                                           off_t offset); }
 672 490     STD     BSD     { int vmspace_munmap(void *id, void *addr,      \
 673                                           size_t len); }
 674 491     STD     BSD     { int vmspace_mcontrol(void *id, void *addr,    \
 675                                           size_t len, int behav, off_t value); }
 676 492     STD     BSD     { ssize_t vmspace_pread(void *id, void *buf, \
 677                             size_t nbyte, int flags, off_t offset); }
 678 493     STD     BSD     { ssize_t vmspace_pwrite(void *id, const void *buf, \
 679                             size_t nbyte, int flags, off_t offset); }
 680 494     STD     BSD     { void extexit(int how, int status, void *addr); }
 681 495     STD     BSD     { int lwp_create(struct lwp_params *params); }
 682 496     STD     BSD     { lwpid_t lwp_gettid(void); }
 683 497     STD     BSD     { int lwp_kill(pid_t pid, lwpid_t tid, int signum); }
 684 498     STD     BSD     { int lwp_rtprio(int function, pid_t pid, lwpid_t tid, struct rtprio *rtp); }
 685 499     STD     BSD     { int pselect(int nd, fd_set *in, fd_set *ou, \
 686                             fd_set *ex, const struct timespec *ts,    \
 687                             const sigset_t *sigmask); }
 688 500     STD     BSD     { int statvfs(const char *path, struct statvfs *buf); }
 689 501     STD     BSD     { int fstatvfs(int fd, struct statvfs *buf); }
 690 502     STD     BSD     { int fhstatvfs(const struct fhandle *u_fhp, struct statvfs *buf); }
 691 503     STD     BSD     { int getvfsstat(struct statfs *buf,          \
 692                             struct statvfs *vbuf, long vbufsize, int flags); }