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