sys/ia64/ia32/syscalls.master

   1  $FreeBSD$
   2 ;       from: @(#)syscalls.master       8.2 (Berkeley) 1/13/94
   3 ;       from: src/sys/kern/syscalls.master 1.107
   4 ;
   5 ; System call name/number master file.
   6 ; Processed to created init_sysent.c, syscalls.c and syscall.h.
   7
   8 ; Columns: number [M]type nargs namespc name alt{name,tag,rtyp}/comments
   9 ;       number  system call number, must be in order
  10 ;       type    one of [M]STD, [M]OBSOL, [M]UNIMPL, [M]COMPAT, [M]CPT_NOA,
  11 ;               [M]LIBCOMPAT, [M]NODEF,  [M]NOARGS,  [M]NOPROTO,  [M]NOIMPL,
  12 ;               [M]NOSTD
  13 ;       namespc one of POSIX, BSD, NOHIDE
  14 ;       name    psuedo-prototype of syscall routine
  15 ;               If one of the following alts is different, then all appear:
  16 ;       altname name of system call if different
  17 ;       alttag  name of args struct tag if different from [o]`name'"_args"
  18 ;       altrtyp return type if not int (bogus - syscalls always return int)
  19 ;               for UNIMPL/OBSOL, name continues with comments
  20
  21 ; types:
  22 ;       [M]     e.g. like MSTD -- means the system call is MP-safe.  If no
  23 ;               M prefix is used, the syscall wrapper will obtain the Giant
  24 ;               lock for the syscall.
  25 ;       STD     always included
  26 ;       COMPAT  included on COMPAT #ifdef
  27 ;       LIBCOMPAT included on COMPAT #ifdef, and placed in syscall.h
  28 ;       OBSOL   obsolete, not included in system, only specifies name
  29 ;       UNIMPL  not implemented, placeholder only
  30 ;       NOSTD   implemented but as a lkm that can be statically
  31 ;                       compiled in sysent entry will be filled with lkmsys
  32 ;                       so the SYSCALL_MODULE macro works
  33
  34 ; #ifdef's, etc. may be included, and are copied to the output files.
  35
  36 #include <sys/param.h>
  37 #include <sys/sysent.h>
  38 #include <sys/sysproto.h>
  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       MSTD    NOHIDE  { void sys_exit(int rval); } exit sys_exit_args void
  48 2       MSTD    POSIX   { int fork(void); }
  49 3       MSTD    POSIX   { ssize_t read(int fd, void *buf, size_t nbyte); }
  50 4       MSTD    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       MSTD    POSIX   { int close(int fd); }
  56 7       MSTD    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      MSTD    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      MSTD    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      MSTD    POSIX   { int setuid(uid_t uid); }
  77 24      MSTD    POSIX   { uid_t getuid(void); }
  78 25      MSTD    POSIX   { uid_t geteuid(void); }
  79 26      STD     BSD     { int ptrace(int req, pid_t pid, caddr_t addr, \
  80                             int data); }
  81 27      MSTD    BSD     { int recvmsg(int s, struct msghdr *msg, int flags); }
  82 28      MSTD    BSD     { int sendmsg(int s, caddr_t msg, int flags); }
  83 29      MSTD    BSD     { int recvfrom(int s, caddr_t buf, size_t len, \
  84                             int flags, caddr_t from, int *fromlenaddr); }
  85 30      MSTD    BSD     { int accept(int s, caddr_t name, int *anamelen); }
  86 31      MSTD    BSD     { int getpeername(int fdes, caddr_t asa, int *alen); }
  87 32      MSTD    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      MSTD    POSIX   { int kill(int pid, int signum); }
  93 38      COMPAT  POSIX   { int stat(char *path, struct ostat *ub); }
  94 39      MSTD    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      MSTD    POSIX   { gid_t getegid(void); }
  99 44      MSTD    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      MCOMPAT POSIX   { int sigaction(int signum, struct osigaction *nsa, \
 104                             struct osigaction *osa); }
 105 47      MSTD    POSIX   { gid_t getgid(void); }
 106 48      MCOMPAT POSIX   { int sigprocmask(int how, osigset_t mask); }
 107 ; XXX note nonstandard (bogus) calling convention - the libc stub passes
 108 ; us the mask, not a pointer to it, and we return the old mask as the
 109 ; (int) return value.
 110 49      MSTD    BSD     { int getlogin(char *namebuf, u_int namelen); }
 111 50      MSTD    BSD     { int setlogin(char *namebuf); }
 112 51      MSTD    BSD     { int acct(char *path); }
 113 52      MCOMPAT POSIX   { int sigpending(void); }
 114 53      MSTD    BSD     { int sigaltstack(stack_t *ss, stack_t *oss); }
 115 54      MSTD    POSIX   { int ioctl(int fd, u_long com, caddr_t data); }
 116 55      MSTD    BSD     { int reboot(int opt); }
 117 56      STD     POSIX   { int revoke(char *path); }
 118 57      STD     POSIX   { int symlink(char *path, char *link); }
 119 58      STD     POSIX   { int readlink(char *path, char *buf, int count); }
 120 59      MSTD    POSIX   { int execve(char *fname, char **argv, char **envv); }
 121 60      MSTD    POSIX   { int umask(int newmask); } umask umask_args int
 122 61      STD     BSD     { int chroot(char *path); }
 123 62      MCOMPAT POSIX   { int fstat(int fd, struct ostat *sb); }
 124 63      MCOMPAT BSD     { int getkerninfo(int op, char *where, size_t *size, \
 125                             int arg); } getkerninfo getkerninfo_args int
 126 64      MCOMPAT BSD     { int getpagesize(void); } \
 127                             getpagesize getpagesize_args int
 128 65      STD     BSD     { int msync(void *addr, size_t len, int flags); }
 129 66      MSTD    BSD     { int vfork(void); }
 130 67      OBSOL   NOHIDE  vread
 131 68      OBSOL   NOHIDE  vwrite
 132 69      MSTD    BSD     { int sbrk(int incr); }
 133 70      MSTD    BSD     { int sstk(int incr); }
 134 71      MCOMPAT BSD     { int mmap(void *addr, int len, int prot, \
 135                             int flags, int fd, long pos); }
 136 72      MSTD    BSD     { int ovadvise(int anom); } vadvise ovadvise_args int
 137 73      MSTD    BSD     { int munmap(void *addr, size_t len); }
 138 74      MSTD    BSD     { int mprotect(const void *addr, size_t len, int prot); }
 139 75      MSTD    BSD     { int madvise(void *addr, size_t len, int behav); }
 140 76      OBSOL   NOHIDE  vhangup
 141 77      OBSOL   NOHIDE  vlimit
 142 78      MSTD    BSD     { int mincore(const void *addr, size_t len, \
 143                             char *vec); }
 144 79      MSTD    POSIX   { int getgroups(u_int gidsetsize, gid_t *gidset); }
 145 80      MSTD    POSIX   { int setgroups(u_int gidsetsize, gid_t *gidset); }
 146 81      MSTD    POSIX   { int getpgrp(void); }
 147 82      MSTD    POSIX   { int setpgid(int pid, int pgid); }
 148 83      MSTD    BSD     { int setitimer(u_int which, struct itimerval *itv, \
 149                             struct itimerval *oitv); }
 150 84      MCOMPAT BSD     { int wait(void); }
 151 85      MSTD    BSD     { int swapon(char *name); }
 152 86      MSTD    BSD     { int getitimer(u_int which, struct itimerval *itv); }
 153 87      MCOMPAT BSD     { int gethostname(char *hostname, u_int len); } \
 154                             gethostname gethostname_args int
 155 88      MCOMPAT BSD     { int sethostname(char *hostname, u_int len); } \
 156                             sethostname sethostname_args int
 157 89      MSTD    BSD     { int getdtablesize(void); }
 158 90      MSTD    POSIX   { int dup2(u_int from, u_int to); }
 159 91      UNIMPL  BSD     getdopt
 160 92      MSTD    POSIX   { int fcntl(int fd, int cmd, long arg); }
 161 ; XXX should be         { int fcntl(int fd, int cmd, ...); }
 162 ; but we're not ready for varargs.
 163 ; XXX man page says `int arg' too.
 164 93      MSTD    BSD     { int select(int nd, fd_set *in, fd_set *ou, \
 165                             fd_set *ex, struct timeval *tv); }
 166 94      UNIMPL  BSD     setdopt
 167 95      STD     POSIX   { int fsync(int fd); }
 168 96      MSTD    BSD     { int setpriority(int which, int who, int prio); }
 169 97      MSTD    BSD     { int socket(int domain, int type, int protocol); }
 170 98      MSTD    BSD     { int connect(int s, caddr_t name, int namelen); }
 171 99      MCPT_NOA BSD    { int accept(int s, caddr_t name, int *anamelen); } \
 172                             accept accept_args int
 173 100     MSTD    BSD     { int getpriority(int which, int who); }
 174 101     MCOMPAT BSD     { int send(int s, caddr_t buf, int len, int flags); }
 175 102     MCOMPAT BSD     { int recv(int s, caddr_t buf, int len, int flags); }
 176 103     STD     BSD     { int osigreturn(struct osigcontext *sigcntxp); }
 177 104     MSTD    BSD     { int bind(int s, caddr_t name, int namelen); }
 178 105     MSTD    BSD     { int setsockopt(int s, int level, int name, \
 179                             caddr_t val, int valsize); }
 180 106     MSTD    BSD     { int listen(int s, int backlog); }
 181 107     OBSOL   NOHIDE  vtimes
 182 108     MCOMPAT BSD     { int sigvec(int signum, struct sigvec *nsv, \
 183                             struct sigvec *osv); }
 184 109     MCOMPAT BSD     { int sigblock(int mask); }
 185 110     MCOMPAT BSD     { int sigsetmask(int mask); }
 186 111     MCOMPAT POSIX   { int sigsuspend(osigset_t mask); }
 187 ; XXX note nonstandard (bogus) calling convention - the libc stub passes
 188 ; us the mask, not a pointer to it.
 189 112     MCOMPAT BSD     { int sigstack(struct sigstack *nss, \
 190                             struct sigstack *oss); }
 191 113     MCOMPAT BSD     { int recvmsg(int s, struct omsghdr *msg, int flags); }
 192 114     MCOMPAT BSD     { int sendmsg(int s, caddr_t msg, int flags); }
 193 115     OBSOL   NOHIDE  vtrace
 194 116     MSTD    BSD     { int gettimeofday(struct timeval *tp, \
 195                             struct timezone *tzp); }
 196 117     MSTD    BSD     { int getrusage(int who, struct rusage *rusage); }
 197 118     MSTD    BSD     { int getsockopt(int s, int level, int name, \
 198                             caddr_t val, int *avalsize); }
 199 119     UNIMPL  NOHIDE  resuba (BSD/OS 2.x)
 200 120     MSTD    BSD     { int readv(int fd, struct iovec *iovp, u_int iovcnt); }
 201 121     MSTD    BSD     { int writev(int fd, struct iovec *iovp, \
 202                             u_int iovcnt); }
 203 122     MSTD    BSD     { int settimeofday(struct timeval *tv, \
 204                             struct timezone *tzp); }
 205 123     STD     BSD     { int fchown(int fd, int uid, int gid); }
 206 124     STD     BSD     { int fchmod(int fd, int mode); }
 207 125     MCPT_NOA BSD    { int recvfrom(int s, caddr_t buf, size_t len, \
 208                             int flags, caddr_t from, int *fromlenaddr); } \
 209                             recvfrom recvfrom_args int
 210 126     MSTD    BSD     { int setreuid(int ruid, int euid); }
 211 127     MSTD    BSD     { int setregid(int rgid, int egid); }
 212 128     STD     POSIX   { int rename(char *from, char *to); }
 213 129     COMPAT  BSD     { int truncate(char *path, long length); }
 214 130     COMPAT  BSD     { int ftruncate(int fd, long length); }
 215 131     MSTD    BSD     { int flock(int fd, int how); }
 216 132     STD     POSIX   { int mkfifo(char *path, int mode); }
 217 133     MSTD    BSD     { int sendto(int s, caddr_t buf, size_t len, \
 218                             int flags, caddr_t to, int tolen); }
 219 134     MSTD    BSD     { int shutdown(int s, int how); }
 220 135     MSTD    BSD     { int socketpair(int domain, int type, int protocol, \
 221                             int *rsv); }
 222 136     STD     POSIX   { int mkdir(char *path, int mode); }
 223 137     STD     POSIX   { int rmdir(char *path); }
 224 138     STD     BSD     { int utimes(char *path, struct timeval *tptr); }
 225 139     OBSOL   NOHIDE  4.2 sigreturn
 226 140     MSTD    BSD     { int adjtime(struct timeval *delta, \
 227                             struct timeval *olddelta); }
 228 141     MCOMPAT BSD     { int getpeername(int fdes, caddr_t asa, int *alen); }
 229 142     MCOMPAT BSD     { long gethostid(void); }
 230 143     MCOMPAT BSD     { int sethostid(long hostid); }
 231 144     MCOMPAT BSD     { int getrlimit(u_int which, struct orlimit *rlp); }
 232 145     MCOMPAT BSD     { int setrlimit(u_int which, struct orlimit *rlp); }
 233 146     MCOMPAT BSD     { int killpg(int pgid, int signum); }
 234 147     MSTD    POSIX   { int setsid(void); }
 235 148     STD     BSD     { int quotactl(char *path, int cmd, int uid, \
 236                             caddr_t arg); }
 237 149     MCOMPAT BSD     { int quota(void); }
 238 150     MCPT_NOA BSD    { int getsockname(int fdec, caddr_t asa, int *alen); }\
 239                             getsockname getsockname_args int
 240
 241 ; Syscalls 151-180 inclusive are reserved for vendor-specific
 242 ; system calls.  (This includes various calls added for compatibity
 243 ; with other Unix variants.)
 244 ; Some of these calls are now supported by BSD...
 245 151     UNIMPL  NOHIDE  sem_lock (BSD/OS 2.x)
 246 152     UNIMPL  NOHIDE  sem_wakeup (BSD/OS 2.x)
 247 153     UNIMPL  NOHIDE  asyncdaemon (BSD/OS 2.x)
 248 154     UNIMPL  NOHIDE  nosys
 249 ; 155 is initialized by the NFS code, if present.
 250 155     MNOIMPL BSD     { int nfssvc(int flag, caddr_t argp); }
 251 156     COMPAT  BSD     { int getdirentries(int fd, char *buf, u_int count, \
 252                             long *basep); }
 253 157     STD     BSD     { int statfs(char *path, struct statfs *buf); }
 254 158     STD     BSD     { int fstatfs(int fd, struct statfs *buf); }
 255 159     UNIMPL  NOHIDE  nosys
 256 160     UNIMPL  NOHIDE  nosys
 257 161     STD     BSD     { int getfh(char *fname, struct fhandle *fhp); }
 258 162     MSTD    BSD     { int getdomainname(char *domainname, int len); }
 259 163     MSTD    BSD     { int setdomainname(char *domainname, int len); }
 260 164     MSTD    BSD     { int uname(struct utsname *name); }
 261 165     STD     BSD     { int sysarch(int op, char *parms); }
 262 166     MSTD    BSD     { int rtprio(int function, pid_t pid, \
 263                             struct rtprio *rtp); }
 264 167     UNIMPL  NOHIDE  nosys
 265 168     UNIMPL  NOHIDE  nosys
 266 ; 169 is initialized by the SYSVSEM code if present or loaded
 267 169     MNOSTD  BSD     { int semsys(int which, int a2, int a3, int a4, \
 268                             int a5); }
 269 ; 169 is initialized by the SYSVMSG code if present or loaded
 270 ; XXX should be         { int semsys(int which, ...); }
 271 170     MNOSTD  BSD     { int msgsys(int which, int a2, int a3, int a4, \
 272                             int a5, int a6); }
 273 ; 169 is initialized by the SYSVSHM code if present or loaded
 274 ; XXX should be         { int msgsys(int which, ...); }
 275 171     MNOSTD  BSD     { int shmsys(int which, int a2, int a3, int a4); }
 276 ; XXX should be         { int shmsys(int which, ...); }
 277 172     UNIMPL  NOHIDE  nosys
 278 173     MSTD    POSIX   { ssize_t pread(int fd, void *buf, size_t nbyte, \
 279                             int pad, off_t offset); }
 280 174     MSTD    POSIX   { ssize_t pwrite(int fd, const void *buf, \
 281                             size_t nbyte, int pad, off_t offset); }
 282 175     UNIMPL  NOHIDE  nosys
 283 176     MSTD    BSD     { int ntp_adjtime(struct timex *tp); }
 284 177     UNIMPL  NOHIDE  sfork (BSD/OS 2.x)
 285 178     UNIMPL  NOHIDE  getdescriptor (BSD/OS 2.x)
 286 179     UNIMPL  NOHIDE  setdescriptor (BSD/OS 2.x)
 287 180     UNIMPL  NOHIDE  nosys
 288
 289 ; Syscalls 181-199 are used by/reserved for BSD
 290 181     MSTD    POSIX   { int setgid(gid_t gid); }
 291 182     MSTD    BSD     { int setegid(gid_t egid); }
 292 183     MSTD    BSD     { int seteuid(uid_t euid); }
 293 184     UNIMPL  BSD     lfs_bmapv
 294 185     UNIMPL  BSD     lfs_markv
 295 186     UNIMPL  BSD     lfs_segclean
 296 187     UNIMPL  BSD     lfs_segwait
 297 188     STD     POSIX   { int stat(char *path, struct stat *ub); }
 298 189     MSTD    POSIX   { int fstat(int fd, struct stat *sb); }
 299 190     STD     POSIX   { int lstat(char *path, struct stat *ub); }
 300 191     STD     POSIX   { int pathconf(char *path, int name); }
 301 192     MSTD    POSIX   { int fpathconf(int fd, int name); }
 302 193     UNIMPL  NOHIDE  nosys
 303 194     MSTD    BSD     { int getrlimit(u_int which, \
 304                             struct rlimit *rlp); } \
 305                             getrlimit __getrlimit_args int
 306 195     MSTD    BSD     { int setrlimit(u_int which, \
 307                             struct rlimit *rlp); } \
 308                             setrlimit __setrlimit_args int
 309 196     STD     BSD     { int getdirentries(int fd, char *buf, u_int count, \
 310                             long *basep); }
 311 197     MSTD    BSD     { caddr_t mmap(caddr_t addr, size_t len, int prot, \
 312                             int flags, int fd, int pad, off_t pos); }
 313 198     STD     NOHIDE  { int nosys(void); } __syscall __syscall_args int
 314 199     STD     POSIX   { off_t lseek(int fd, int pad, off_t offset, \
 315                             int whence); }
 316 200     STD     BSD     { int truncate(char *path, int pad, off_t length); }
 317 201     STD     BSD     { int ftruncate(int fd, int pad, off_t length); }
 318 202     MSTD    BSD     { int __sysctl(int *name, u_int namelen, void *old, \
 319                             size_t *oldlenp, void *new, size_t newlen); } \
 320                             __sysctl sysctl_args int
 321 ; properly, __sysctl should be a NOHIDE, but making an exception
 322 ; here allows to avoid one in libc/sys/Makefile.inc.
 323 203     MSTD    BSD     { int mlock(const void *addr, size_t len); }
 324 204     MSTD    BSD     { int munlock(const void *addr, size_t len); }
 325 205     STD     BSD     { int undelete(char *path); }
 326 206     STD     BSD     { int futimes(int fd, struct timeval *tptr); }
 327 207     MSTD    BSD     { int getpgid(pid_t pid); }
 328 208     UNIMPL  NOHIDE  newreboot (NetBSD)
 329 209     MSTD    BSD     { int poll(struct pollfd *fds, u_int nfds, \
 330                             int timeout); }
 331
 332 ;
 333 ; The following are reserved for loadable syscalls
 334 ;
 335 210     NODEF   NOHIDE  lkmnosys lkmnosys nosys_args int
 336 211     NODEF   NOHIDE  lkmnosys lkmnosys nosys_args int
 337 212     NODEF   NOHIDE  lkmnosys lkmnosys nosys_args int
 338 213     NODEF   NOHIDE  lkmnosys lkmnosys nosys_args int
 339 214     NODEF   NOHIDE  lkmnosys lkmnosys nosys_args int
 340 215     NODEF   NOHIDE  lkmnosys lkmnosys nosys_args int
 341 216     NODEF   NOHIDE  lkmnosys lkmnosys nosys_args int
 342 217     NODEF   NOHIDE  lkmnosys lkmnosys nosys_args int
 343 218     NODEF   NOHIDE  lkmnosys lkmnosys nosys_args int
 344 219     NODEF   NOHIDE  lkmnosys lkmnosys nosys_args int
 345
 346 ;
 347 ; The following were introduced with NetBSD/4.4Lite-2
 348 ; They are initialized by thier respective modules/sysinits
 349 220     MNOSTD  BSD     { int __semctl(int semid, int semnum, int cmd, \
 350                             union semun *arg); }
 351 221     MNOSTD  BSD     { int semget(key_t key, int nsems, int semflg); }
 352 222     MNOSTD  BSD     { int semop(int semid, struct sembuf *sops, \
 353                             u_int nsops); }
 354 223     UNIMPL  NOHIDE  semconfig
 355 224     MNOSTD  BSD     { int msgctl(int msqid, int cmd, \
 356                             struct msqid_ds *buf); }
 357 225     MNOSTD  BSD     { int msgget(key_t key, int msgflg); }
 358 226     MNOSTD  BSD     { int msgsnd(int msqid, void *msgp, size_t msgsz, \
 359                             int msgflg); }
 360 227     MNOSTD  BSD     { int msgrcv(int msqid, void *msgp, size_t msgsz, \
 361                             long msgtyp, int msgflg); }
 362 228     MNOSTD  BSD     { int shmat(int shmid, void *shmaddr, int shmflg); }
 363 229     MNOSTD  BSD     { int shmctl(int shmid, int cmd, \
 364                             struct shmid_ds *buf); }
 365 230     MNOSTD  BSD     { int shmdt(void *shmaddr); }
 366 231     MNOSTD  BSD     { int shmget(key_t key, int size, int shmflg); }
 367 ;
 368 232     MSTD    POSIX   { int clock_gettime(clockid_t clock_id, \
 369                             struct timespec *tp); }
 370 233     MSTD    POSIX   { int clock_settime(clockid_t clock_id, \
 371                             const struct timespec *tp); }
 372 234     MSTD    POSIX   { int clock_getres(clockid_t clock_id, \
 373                             struct timespec *tp); }
 374 235     UNIMPL  NOHIDE  timer_create
 375 236     UNIMPL  NOHIDE  timer_delete
 376 237     UNIMPL  NOHIDE  timer_settime
 377 238     UNIMPL  NOHIDE  timer_gettime
 378 239     UNIMPL  NOHIDE  timer_getoverrun
 379 240     MSTD    POSIX   { int nanosleep(const struct timespec *rqtp, \
 380                             struct timespec *rmtp); }
 381 241     UNIMPL  NOHIDE  nosys
 382 242     UNIMPL  NOHIDE  nosys
 383 243     UNIMPL  NOHIDE  nosys
 384 244     UNIMPL  NOHIDE  nosys
 385 245     UNIMPL  NOHIDE  nosys
 386 246     UNIMPL  NOHIDE  nosys
 387 247     UNIMPL  NOHIDE  nosys
 388 248     UNIMPL  NOHIDE  nosys
 389 249     UNIMPL  NOHIDE  nosys
 390 ; syscall numbers initially used in OpenBSD
 391 250     MSTD    BSD     { int minherit(void *addr, size_t len, int inherit); }
 392 251     MSTD    BSD     { int rfork(int flags); }
 393 252     MSTD    BSD     { int openbsd_poll(struct pollfd *fds, u_int nfds, \
 394                             int timeout); }
 395 253     STD     BSD     { int issetugid(void); }
 396 254     STD     BSD     { int lchown(char *path, int uid, int gid); }
 397 255     UNIMPL  NOHIDE  nosys
 398 256     UNIMPL  NOHIDE  nosys
 399 257     UNIMPL  NOHIDE  nosys
 400 258     UNIMPL  NOHIDE  nosys
 401 259     UNIMPL  NOHIDE  nosys
 402 260     UNIMPL  NOHIDE  nosys
 403 261     UNIMPL  NOHIDE  nosys
 404 262     UNIMPL  NOHIDE  nosys
 405 263     UNIMPL  NOHIDE  nosys
 406 264     UNIMPL  NOHIDE  nosys
 407 265     UNIMPL  NOHIDE  nosys
 408 266     UNIMPL  NOHIDE  nosys
 409 267     UNIMPL  NOHIDE  nosys
 410 268     UNIMPL  NOHIDE  nosys
 411 269     UNIMPL  NOHIDE  nosys
 412 270     UNIMPL  NOHIDE  nosys
 413 271     UNIMPL  NOHIDE  nosys
 414 272     STD     BSD     { int getdents(int fd, char *buf, size_t count); }
 415 273     UNIMPL  NOHIDE  nosys
 416 274     STD     BSD     { int lchmod(char *path, mode_t mode); }
 417 275     NOPROTO BSD     { int lchown(char *path, uid_t uid, gid_t gid); } netbsd_lchown lchown_args int
 418 276     STD     BSD     { int lutimes(char *path, struct timeval *tptr); }
 419 277     MNOPROTO BSD    { int msync(void *addr, size_t len, int flags); } netbsd_msync msync_args int
 420 278     STD     BSD     { int nstat(char *path, struct nstat *ub); }
 421 279     MSTD    BSD     { int nfstat(int fd, struct nstat *sb); }
 422 280     STD     BSD     { int nlstat(char *path, struct nstat *ub); }
 423 281     UNIMPL  NOHIDE  nosys
 424 282     UNIMPL  NOHIDE  nosys
 425 283     UNIMPL  NOHIDE  nosys
 426 284     UNIMPL  NOHIDE  nosys
 427 285     UNIMPL  NOHIDE  nosys
 428 286     UNIMPL  NOHIDE  nosys
 429 287     UNIMPL  NOHIDE  nosys
 430 288     UNIMPL  NOHIDE  nosys
 431 289     UNIMPL  NOHIDE  nosys
 432 290     UNIMPL  NOHIDE  nosys
 433 291     UNIMPL  NOHIDE  nosys
 434 292     UNIMPL  NOHIDE  nosys
 435 293     UNIMPL  NOHIDE  nosys
 436 294     UNIMPL  NOHIDE  nosys
 437 295     UNIMPL  NOHIDE  nosys
 438 296     UNIMPL  NOHIDE  nosys
 439 ; XXX 297 is 300 in NetBSD
 440 297     STD     BSD     { int fhstatfs(const struct fhandle *u_fhp, struct statfs *buf); }
 441 298     STD     BSD     { int fhopen(const struct fhandle *u_fhp, int flags); }
 442 299     STD     BSD     { int fhstat(const struct fhandle *u_fhp, struct stat *sb); }
 443 ; syscall numbers for FreeBSD
 444 300     MSTD    BSD     { int modnext(int modid); }
 445 301     MSTD    BSD     { int modstat(int modid, struct module_stat* stat); }
 446 302     MSTD    BSD     { int modfnext(int modid); }
 447 303     MSTD    BSD     { int modfind(const char *name); }
 448 304     MSTD    BSD     { int kldload(const char *file); }
 449 305     MSTD    BSD     { int kldunload(int fileid); }
 450 306     MSTD    BSD     { int kldfind(const char *file); }
 451 307     MSTD    BSD     { int kldnext(int fileid); }
 452 308     MSTD    BSD     { int kldstat(int fileid, struct kld_file_stat* stat); }
 453 309     MSTD    BSD     { int kldfirstmod(int fileid); }
 454 310     MSTD    BSD     { int getsid(pid_t pid); }
 455 311     MSTD    BSD     { int setresuid(uid_t ruid, uid_t euid, uid_t suid); }
 456 312     MSTD    BSD     { int setresgid(gid_t rgid, gid_t egid, gid_t sgid); }
 457 313     OBSOL   NOHIDE  signanosleep
 458 314     NOSTD   BSD     { int aio_return(struct aiocb *aiocbp); }
 459 315     NOSTD   BSD     { int aio_suspend(struct aiocb * const * aiocbp, int nent, const struct timespec *timeout); }
 460 316     NOSTD   BSD     { int aio_cancel(int fd, struct aiocb *aiocbp); }
 461 317     NOSTD   BSD     { int aio_error(struct aiocb *aiocbp); }
 462 318     NOSTD   BSD     { int aio_read(struct aiocb *aiocbp); }
 463 319     NOSTD   BSD     { int aio_write(struct aiocb *aiocbp); }
 464 320     NOSTD   BSD     { int lio_listio(int mode, struct aiocb * const *acb_list, int nent, struct sigevent *sig); }
 465 321     MSTD    BSD     { int yield(void); }
 466 322     OBSOL   NOHIDE  thr_sleep
 467 323     OBSOL   NOHIDE  thr_wakeup
 468 324     MSTD    BSD     { int mlockall(int how); }
 469 325     MSTD    BSD     { int munlockall(void); }
 470 326     STD     BSD     { int __getcwd(u_char *buf, u_int buflen); }
 471
 472 327     MSTD     POSIX   { int sched_setparam (pid_t pid, const struct sched_param *param); }
 473 328     MSTD     POSIX   { int sched_getparam (pid_t pid, struct sched_param *param); }
 474
 475 329     MSTD     POSIX   { int sched_setscheduler (pid_t pid, int policy, const struct sched_param *param); }
 476 330     MSTD     POSIX   { int sched_getscheduler (pid_t pid); }
 477
 478 331     MSTD     POSIX   { int sched_yield (void); }
 479 332     MSTD     POSIX   { int sched_get_priority_max (int policy); }
 480 333     MSTD     POSIX   { int sched_get_priority_min (int policy); }
 481 334     MSTD     POSIX   { int sched_rr_get_interval (pid_t pid, struct timespec *interval); }
 482 335     STD     BSD     { int utrace(const void *addr, size_t len); }
 483 336     MSTD    BSD     { int sendfile(int fd, int s, off_t offset, size_t nbytes, \
 484                                 struct sf_hdtr *hdtr, off_t *sbytes, int flags); }
 485 337     STD     BSD     { int kldsym(int fileid, int cmd, void *data); }
 486 338     MSTD    BSD     { int jail(struct jail *jail); }
 487 339     UNIMPL  BSD     pioctl
 488 340     MSTD    POSIX   { int sigprocmask(int how, const sigset_t *set, \
 489                             sigset_t *oset); }
 490 341     MSTD    POSIX   { int sigsuspend(const sigset_t *sigmask); }
 491 342     MSTD    POSIX   { int sigaction(int sig, const struct sigaction *act, \
 492                             struct sigaction *oact); }
 493 343     MSTD    POSIX   { int sigpending(sigset_t *set); }
 494 344     STD     BSD     { int sigreturn(const struct __ucontext *sigcntxp); }
 495 345     UNIMPL  NOHIDE  sigtimedwait
 496 346     UNIMPL  NOHIDE  sigwaitinfo
 497 347     MSTD    BSD     { int __acl_get_file(const char *path, \
 498                             acl_type_t type, struct acl *aclp); }
 499 348     MSTD    BSD     { int __acl_set_file(const char *path, \
 500                             acl_type_t type, struct acl *aclp); }
 501 349     MSTD    BSD     { int __acl_get_fd(int filedes, acl_type_t type, \
 502                             struct acl *aclp); }
 503 350     MSTD    BSD     { int __acl_set_fd(int filedes, acl_type_t type, \
 504                             struct acl *aclp); }
 505 351     MSTD    BSD     { int __acl_delete_file(const char *path, \
 506                             acl_type_t type); }
 507 352     MSTD    BSD     { int __acl_delete_fd(int filedes, acl_type_t type); }
 508 353     MSTD    BSD     { int __acl_aclcheck_file(const char *path, \
 509                             acl_type_t type, struct acl *aclp); }
 510 354     MSTD    BSD     { int __acl_aclcheck_fd(int filedes, acl_type_t type, \
 511                             struct acl *aclp); }
 512 355     STD     BSD     { int extattrctl(const char *path, int cmd, \
 513                             const char *filename, int attrnamespace, \
 514                             const char *attrname); }
 515 356     STD     BSD     { int extattr_set_file(const char *path, \
 516                             int attrnamespace, const char *attrname, \
 517                             void *data, size_t nbytes); }
 518 357     STD     BSD     { ssize_t extattr_get_file(const char *path, \
 519                             int attrnamespace, const char *attrname, \
 520                             void *data, size_t nbytes); }
 521 358     STD     BSD     { int extattr_delete_file(const char *path, \
 522                             int attrnamespace, const char *attrname); }
 523 359     NOSTD   BSD     { int aio_waitcomplete(struct aiocb **aiocbp, struct timespec *timeout); }
 524 360     MSTD    BSD     { int getresuid(uid_t *ruid, uid_t *euid, uid_t *suid); }
 525 361     MSTD    BSD     { int getresgid(gid_t *rgid, gid_t *egid, gid_t *sgid); }
 526 362     MSTD    BSD     { int kqueue(void); }
 527 363     MSTD    BSD     { int kevent(int fd, \
 528                             const struct kevent *changelist, int nchanges, \
 529                             struct kevent *eventlist, int nevents, \
 530                             const struct timespec *timeout); }
 531 364     STD     BSD     { int __cap_get_proc(struct cap *cap_p); }
 532 365     STD     BSD     { int __cap_set_proc(struct cap *cap_p); }
 533 366     STD     BSD     { int __cap_get_fd(int fd, struct cap *cap_p); }
 534 367     STD     BSD     { int __cap_get_file(const char *path_p, struct cap *cap_p); }
 535 368     STD     BSD     { int __cap_set_fd(int fd, struct cap *cap_p); }
 536 369     STD     BSD     { int __cap_set_file(const char *path_p, struct cap *cap_p); }
 537 370     NODEF   NOHIDE  lkmressys lkmressys nosys_args int
 538 371     STD     BSD     { int extattr_set_fd(int fd, int attrnamespace, \
 539                             const char *attrname, void *data, \
 540                             size_t nbytes); }
 541 372     STD     BSD     { ssize_t extattr_get_fd(int fd, int attrnamespace, \
 542                             const char *attrname, void *data, size_t nbytes); }
 543 373     STD     BSD     { int extattr_delete_fd(int fd, int attrnamespace, \
 544                             const char *attrname); }
 545 374     MSTD    BSD     { int __setugid(int flag); }
 546 375     NOIMPL  BSD     { int nfsclnt(int flag, caddr_t argp); }
 547 376     STD     BSD     { int eaccess(char *path, int flags); }
 548 377     UNIMPL  BSD     afs_syscall
 549 378     STD     BSD     { int nmount(struct iovec *iovp, unsigned int iovcnt, \
 550                             int flags); }
 551 379     STD     BSD     { int kse_exit(void); }
 552 380     STD     BSD     { int kse_wakeup(void); }
 553 381     STD     BSD     { int kse_new(struct kse_mailbox * mbx, \
 554                         int new_grp_flag); }
 555 382     STD     BSD     { int thread_wakeup(struct thread_mailbox *tmbx); }
 556 383     STD     BSD     { int kse_yield(void); }
 557 384     UNIMPL  BSD     __mac_get_proc
 558 385     UNIMPL  BSD     __mac_set_proc
 559 386     UNIMPL  BSD     __mac_get_fd
 560 387     UNIMPL  BSD     __mac_get_file
 561 388     UNIMPL  BSD     __mac_set_fd
 562 389     UNIMPL  BSD     __mac_set_file