sys/kern/syscalls.master

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