sys/kern/syscalls.master

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