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