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