sys/compat/freebsd32/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 #include <sys/mount.h>
  40 #include <ia64/ia32/ia32.h>
  41 #include <ia64/ia32/ia32_proto.h>
  42
  43 ; Reserved/unimplemented system calls in the range 0-150 inclusive
  44 ; are reserved for use in future Berkeley releases.
  45 ; Additional system calls implemented in vendor and other
  46 ; redistributions should be placed in the reserved range at the end
  47 ; of the current calls.
  48
  49 0       MNOPROTO NOHIDE { int nosys(void); } syscall nosys_args int
  50 1       MNOPROTO NOHIDE { void sys_exit(int rval); } exit sys_exit_args void
  51 2       MNOPROTO POSIX  { int fork(void); }
  52 3       MNOPROTO POSIX  { ssize_t read(int fd, void *buf, size_t nbyte); }
  53 4       MNOPROTO POSIX  { ssize_t write(int fd, const void *buf, size_t nbyte); }
  54 5       STD     POSIX   { int ia32_open(char *path, int flags, int mode); }
  55 ; XXX should be         { int open(const char *path, int flags, ...); }
  56 ; but we're not ready for `const' or varargs.
  57 ; XXX man page says `mode_t mode'.
  58 6       MNOPROTO POSIX  { int close(int fd); }
  59 7       MSTD BSD        { int ia32_wait4(int pid, int *status, int options, \
  60                             struct rusage32 *rusage); }
  61 8       OBSOL   BSD     old creat
  62 9       NOPROTO POSIX   { int link(char *path, char *link); }
  63 10      NOPROTO POSIX   { int unlink(char *path); }
  64 11      OBSOL   NOHIDE  execv
  65 12      NOPROTO POSIX   { int chdir(char *path); }
  66 13      NOPROTO BSD     { int fchdir(int fd); }
  67 14      NOPROTO POSIX   { int mknod(char *path, int mode, int dev); }
  68 15      NOPROTO POSIX   { int chmod(char *path, int mode); }
  69 16      NOPROTO POSIX   { int chown(char *path, int uid, int gid); }
  70 17      MNOPROTO BSD    { int obreak(char *nsize); } break obreak_args int
  71 18      STD     BSD     { int ia32_getfsstat(struct statfs32 *buf, \
  72                             long bufsize, int flags); }
  73 19      OBSOL   POSIX   olseek
  74 20      MNOPROTO POSIX  { pid_t getpid(void); }
  75 21      NOPROTO BSD     { int mount(char *type, char *path, int flags, \
  76                             caddr_t data); }
  77 ; XXX `path' should have type `const char *' but we're not ready for that.
  78 22      NOPROTO BSD     { int unmount(char *path, int flags); }
  79 23      MNOPROTO POSIX  { int setuid(uid_t uid); }
  80 24      MNOPROTO POSIX  { uid_t getuid(void); }
  81 25      MNOPROTO POSIX  { uid_t geteuid(void); }
  82 26      NOPROTO BSD     { int ptrace(int req, pid_t pid, caddr_t addr, \
  83                             int data); }
  84 27      UNIMPL  BSD     recvmsg
  85 28      MNOPROTO BSD    { int sendmsg(int s, caddr_t msg, int flags); }
  86 29      MNOPROTO BSD    { int recvfrom(int s, caddr_t buf, size_t len, \
  87                             int flags, caddr_t from, int *fromlenaddr); }
  88 30      MNOPROTO BSD    { int accept(int s, caddr_t name, int *anamelen); }
  89 31      MNOPROTO BSD    { int getpeername(int fdes, caddr_t asa, int *alen); }
  90 32      MNOPROTO BSD    { int getsockname(int fdes, caddr_t asa, int *alen); }
  91 33      STD     POSIX   { int ia32_access(char *path, int flags); }
  92 34      STD     BSD     { int ia32_chflags(char *path, int flags); }
  93 35      NOPROTO BSD     { int fchflags(int fd, int flags); }
  94 36      NOPROTO BSD     { int sync(void); }
  95 37      MNOPROTO POSIX  { int kill(int pid, int signum); }
  96 38      UNIMPL  POSIX   ostat
  97 39      MNOPROTO POSIX  { pid_t getppid(void); }
  98 40      UNIMPL  POSIX   olstat
  99 41      NOPROTO POSIX   { int dup(u_int fd); }
 100 42      NOPROTO POSIX   { int pipe(void); }
 101 43      MNOPROTO POSIX  { gid_t getegid(void); }
 102 44      MNOPROTO BSD    { int profil(caddr_t samples, size_t size, \
 103                             size_t offset, u_int scale); }
 104 45      NOPROTO BSD     { int ktrace(const char *fname, int ops, int facs, \
 105                             int pid); }
 106 46      UNIMPL  POSIX   osigaction
 107 47      MNOPROTO POSIX  { gid_t getgid(void); }
 108 48      UNIMPL  POSIX   osigprocmask
 109 49      MNOPROTO BSD    { int getlogin(char *namebuf, u_int namelen); }
 110 50      MNOPROTO BSD    { int setlogin(char *namebuf); }
 111 51      MNOPROTO BSD    { int acct(char *path); }
 112 52      MNOPROTO POSIX  { int sigpending(void); }
 113 53      STD     BSD     { int ia32_sigaltstack(struct sigaltstack32 *ss, struct sigaltstack32 *oss); }
 114 54      MNOPROTO POSIX  { int ioctl(int fd, u_long com, caddr_t data); }
 115 55      MNOPROTO BSD    { int reboot(int opt); }
 116 56      NOPROTO POSIX   { int revoke(char *path); }
 117 57      NOPROTO POSIX   { int symlink(char *path, char *link); }
 118 58      NOPROTO POSIX   { int readlink(char *path, char *buf, int count); }
 119 59      STD      POSIX  { int ia32_execve(char *fname, u_int32_t *argv, u_int32_t *envv); }
 120 60      MNOPROTO POSIX  { int umask(int newmask); } umask umask_args int
 121 61      NOPROTO BSD     { int chroot(char *path); }
 122 62      OBSOL   POSIX   ofstat
 123 63      OBSOL   BSD     ogetkerninfo
 124 64      OBSOL   BSD     ogetpagesize
 125 65      OBSOL   BSD     omsync
 126 66      OBSOL   BSD     ovfork
 127 67      OBSOL   NOHIDE  vread
 128 68      OBSOL   NOHIDE  vwrite
 129 69      MNOPROTO BSD    { int sbrk(int incr); }
 130 70      MNOPROTO BSD    { int sstk(int incr); }
 131 71      OBSOL   BSD     ommap
 132 72      MNOPROTO BSD    { int ovadvise(int anom); } vadvise ovadvise_args int
 133 73      MNOPROTO BSD    { int munmap(void *addr, size_t len); }
 134 74      MNOPROTO BSD    { int mprotect(const void *addr, size_t len, int prot); }
 135 75      MNOPROTO BSD    { int madvise(void *addr, size_t len, int behav); }
 136 76      OBSOL   NOHIDE  vhangup
 137 77      OBSOL   NOHIDE  vlimit
 138 78      MNOPROTO BSD    { int mincore(const void *addr, size_t len, \
 139                             char *vec); }
 140 79      MNOPROTO POSIX  { int getgroups(u_int gidsetsize, gid_t *gidset); }
 141 80      MNOPROTO POSIX  { int setgroups(u_int gidsetsize, gid_t *gidset); }
 142 81      MNOPROTO POSIX  { int getpgrp(void); }
 143 82      MNOPROTO POSIX  { int setpgid(int pid, int pgid); }
 144 83      STD     BSD     { int ia32_setitimer(u_int which, \
 145                             struct itimerval32 *itv, \
 146                             struct itimerval32 *oitv); }
 147 84      OBSOL   BSD     owait
 148 85      OBSOL   BSD     oswapon
 149 86      OBSOL   BSD     ogetitimer
 150 87      OBSOL   BSD     ogethostname
 151 88      OBSOL   BSD     osethostname
 152 89      MNOPROTO BSD    { int getdtablesize(void); }
 153 90      MNOPROTO POSIX  { int dup2(u_int from, u_int to); }
 154 91      UNIMPL  BSD     getdopt
 155 92      MNOPROTO POSIX  { int fcntl(int fd, int cmd, long arg); }
 156 ; XXX should be         { int fcntl(int fd, int cmd, ...); }
 157 ; but we're not ready for varargs.
 158 ; XXX man page says `int arg' too.
 159 93      STD     BSD     { int ia32_select(int nd, fd_set *in, fd_set *ou, \
 160                             fd_set *ex, struct timeval32 *tv); }
 161 ; XXX need to override for big-endian - little-endian should work fine.
 162 94      UNIMPL  BSD     setdopt
 163 95      NOPROTO POSIX   { int fsync(int fd); }
 164 96      MNOPROTO BSD    { int setpriority(int which, int who, int prio); }
 165 97      MNOPROTO BSD    { int socket(int domain, int type, int protocol); }
 166 98      MNOPROTO BSD    { int connect(int s, caddr_t name, int namelen); }
 167 99      MNOPROTO BSD    { int accept(int s, caddr_t name, int *anamelen); } \
 168                             accept accept_args int
 169 100     MNOPROTO BSD    { int getpriority(int which, int who); }
 170 101     OBSOL   BSD     osend
 171 102     OBSOL   BSD     orecv
 172 103     OBSOL   BSD     osigreturn
 173 104     MNOPROTO BSD    { int bind(int s, caddr_t name, int namelen); }
 174 105     MNOPROTO BSD    { int setsockopt(int s, int level, int name, \
 175                             caddr_t val, int valsize); }
 176 106     MNOPROTO BSD    { int listen(int s, int backlog); }
 177 107     OBSOL   NOHIDE  vtimes
 178 108     OBSOL   BSD     osigvec
 179 109     OBSOL   BSD     osigblock
 180 110     OBSOL   BSD     osigsetmask
 181 111     OBSOL   POSIX   osigsuspend
 182 112     OBSOL   BSD     osigstack
 183 113     OBSOL   BSD     orecvmsg
 184 114     OBSOL   BSD     osendmsg
 185 115     OBSOL   NOHIDE  vtrace
 186 116     STD     BSD     { int ia32_gettimeofday(struct timeval32 *tp, \
 187                             struct timezone *tzp); }
 188 117     STD     BSD     { int ia32_getrusage(int who, struct rusage32 *rusage); }
 189 118     MNOPROTO BSD    { int getsockopt(int s, int level, int name, \
 190                             caddr_t val, int *avalsize); }
 191 119     UNIMPL  NOHIDE  resuba (BSD/OS 2.x)
 192 120     STD     BSD     { int ia32_readv(int fd, struct iovec32 *iovp, u_int iovcnt); }
 193 121     STD     BSD     { int ia32_writev(int fd, struct iovec32 *iovp, \
 194                             u_int iovcnt); }
 195 122     STD     BSD     { int ia32_settimeofday(struct timeval32 *tv, \
 196                             struct timezone *tzp); }
 197 123     NOPROTO BSD     { int fchown(int fd, int uid, int gid); }
 198 124     NOPROTO BSD     { int fchmod(int fd, int mode); }
 199 125     MNOPROTO BSD    { int recvfrom(int s, caddr_t buf, size_t len, \
 200                             int flags, caddr_t from, int *fromlenaddr); } \
 201                             recvfrom recvfrom_args int
 202 126     MNOPROTO BSD    { int setreuid(int ruid, int euid); }
 203 127     MNOPROTO BSD    { int setregid(int rgid, int egid); }
 204 128     NOPROTO POSIX   { int rename(char *from, char *to); }
 205 129     OBSOL   BSD     otruncate
 206 130     OBSOL   BSD     ftruncate
 207 131     MNOPROTO BSD    { int flock(int fd, int how); }
 208 132     NOPROTO POSIX   { int mkfifo(char *path, int mode); }
 209 133     MNOPROTO BSD    { int sendto(int s, caddr_t buf, size_t len, \
 210                             int flags, caddr_t to, int tolen); }
 211 134     MNOPROTO BSD    { int shutdown(int s, int how); }
 212 135     MNOPROTO BSD    { int socketpair(int domain, int type, int protocol, \
 213                             int *rsv); }
 214 136     NOPROTO POSIX   { int mkdir(char *path, int mode); }
 215 137     NOPROTO POSIX   { int rmdir(char *path); }
 216 138     STD     BSD     { int ia32_utimes(char *path, \
 217                             struct timeval32 *tptr); }
 218 139     OBSOL   NOHIDE  4.2 sigreturn
 219 140     STD     BSD     { int ia32_adjtime(struct timeval32 *delta, \
 220                             struct timeval32 *olddelta); }
 221 141     OBSOL   BSD     ogetpeername
 222 142     OBSOL   BSD     ogethostid
 223 143     OBSOL   BSD     sethostid
 224 144     OBSOL   BSD     getrlimit
 225 145     OBSOL   BSD     setrlimit
 226 146     OBSOL   BSD     killpg
 227 147     MNOPROTO POSIX  { int setsid(void); }
 228 148     NOPROTO BSD     { int quotactl(char *path, int cmd, int uid, \
 229                             caddr_t arg); }
 230 149     OBSOL BSD       oquota
 231 150     OBSOL BSD       ogetsockname
 232
 233 ; Syscalls 151-180 inclusive are reserved for vendor-specific
 234 ; system calls.  (This includes various calls added for compatibity
 235 ; with other Unix variants.)
 236 ; Some of these calls are now supported by BSD...
 237 151     UNIMPL  NOHIDE  sem_lock (BSD/OS 2.x)
 238 152     UNIMPL  NOHIDE  sem_wakeup (BSD/OS 2.x)
 239 153     UNIMPL  NOHIDE  asyncdaemon (BSD/OS 2.x)
 240 154     UNIMPL  NOHIDE  nosys
 241 ; 155 is initialized by the NFS code, if present.
 242 155     UNIMPL  NOHIDE  nfssvc
 243 156     NOPROTO BSD     { int getdirentries(int fd, char *buf, u_int count, \
 244                             long *basep); }
 245 157     STD     BSD     { int ia32_statfs(char *path, struct statfs32 *buf); }
 246 158     STD     BSD     { int ia32_fstatfs(int fd, struct statfs32 *buf); }
 247 159     UNIMPL  NOHIDE  nosys
 248 160     UNIMPL  NOHIDE  nosys
 249 161     NOPROTO BSD     { int getfh(char *fname, struct fhandle *fhp); }
 250 162     MNOPROTO BSD    { int getdomainname(char *domainname, int len); }
 251 163     MNOPROTO BSD    { int setdomainname(char *domainname, int len); }
 252 164     MNOPROTO BSD    { int uname(struct utsname *name); }
 253 165     NOPROTO BSD     { int sysarch(int op, char *parms); }
 254 166     MNOPROTO BSD    { int rtprio(int function, pid_t pid, \
 255                             struct rtprio *rtp); }
 256 167     UNIMPL  NOHIDE  nosys
 257 168     UNIMPL  NOHIDE  nosys
 258 169     STD     BSD     { int ia32_semsys(int which, int a2, int a3, int a4, \
 259                             int a5); }
 260 170     STD     BSD     { int ia32_msgsys(int which, int a2, int a3, int a4, \
 261                             int a5, int a6); }
 262 171     STD     BSD     { int ia32_shmsys(int which, int a2, int a3, int a4); }
 263 172     UNIMPL  NOHIDE  nosys
 264 173     STD POSIX       { ssize_t ia32_pread(int fd, void *buf, size_t nbyte, \
 265                             int pad, u_int32_t offsetlo, u_int32_t offsethi); }
 266 ; XXX note - bigendian is different
 267 174     STD     POSIX   { ssize_t ia32_pwrite(int fd, const void *buf, \
 268                             size_t nbyte, int pad, u_int32_t offsetlo, \
 269                             u_int32_t offsethi); }
 270 ; XXX note - bigendian is different
 271 175     UNIMPL  NOHIDE  nosys
 272 176     MNOPROTO BSD    { int ntp_adjtime(struct timex *tp); }
 273 177     UNIMPL  NOHIDE  sfork (BSD/OS 2.x)
 274 178     UNIMPL  NOHIDE  getdescriptor (BSD/OS 2.x)
 275 179     UNIMPL  NOHIDE  setdescriptor (BSD/OS 2.x)
 276 180     UNIMPL  NOHIDE  nosys
 277
 278 ; Syscalls 181-199 are used by/reserved for BSD
 279 181     MNOPROTO POSIX  { int setgid(gid_t gid); }
 280 182     MNOPROTO BSD    { int setegid(gid_t egid); }
 281 183     MNOPROTO BSD    { int seteuid(uid_t euid); }
 282 184     UNIMPL  BSD     lfs_bmapv
 283 185     UNIMPL  BSD     lfs_markv
 284 186     UNIMPL  BSD     lfs_segclean
 285 187     UNIMPL  BSD     lfs_segwait
 286 188     STD     POSIX   { int ia32_stat(char *path, struct stat32 *ub); }
 287 189     STD     POSIX   { int ia32_fstat(int fd, struct stat32 *ub); }
 288 190     STD     POSIX   { int ia32_lstat(char *path, struct stat32 *ub); }
 289 191     NOPROTO POSIX   { int pathconf(char *path, int name); }
 290 192     MNOPROTO POSIX  { int fpathconf(int fd, int name); }
 291 193     UNIMPL  NOHIDE  nosys
 292 194     MNOPROTO BSD    { int getrlimit(u_int which, \
 293                             struct rlimit *rlp); } \
 294                             getrlimit __getrlimit_args int
 295 195     MNOPROTO BSD    { int setrlimit(u_int which, \
 296                             struct rlimit *rlp); } \
 297                             setrlimit __setrlimit_args int
 298 196     NOPROTO BSD     { int getdirentries(int fd, char *buf, u_int count, \
 299                             long *basep); }
 300 197     STD BSD         { caddr_t ia32_mmap(caddr_t addr, size_t len, \
 301                             int prot, int flags, int fd, int pad, \
 302                             u_int32_t poslo, u_int32_t poshi); }
 303 198     NOPROTO NOHIDE  { int nosys(void); } __syscall __syscall_args int
 304 ; XXX note - bigendian is different
 305 199     STD     POSIX   { off_t ia32_lseek(int fd, int pad, \
 306                             u_int32_t offsetlo, u_int32_t offsethi, \
 307                             int whence); }
 308 ; XXX note - bigendian is different
 309 200     STD     BSD     { int ia32_truncate(char *path, int pad, \
 310                             u_int32_t lengthlo, u_int32_t lengthhi); }
 311 ; XXX note - bigendian is different
 312 201     STD     BSD     { int ia32_ftruncate(int fd, int pad, \
 313                             u_int32_t lengthlo, u_int32_t lengthhi); }
 314 202     MSTD BSD        { int ia32_sysctl(int *name, u_int namelen, \
 315                             void *old, u_int32_t *oldlenp, void *new, \
 316                             u_int32_t newlen); }
 317 203     MNOPROTO BSD    { int mlock(const void *addr, size_t len); }
 318 204     MNOPROTO BSD    { int munlock(const void *addr, size_t len); }
 319 205     NOPROTO BSD     { int undelete(char *path); }
 320 206     NOPROTO BSD     { int futimes(int fd, struct timeval *tptr); }
 321 207     MNOPROTO BSD    { int getpgid(pid_t pid); }
 322 208     UNIMPL  NOHIDE  newreboot (NetBSD)
 323 209     MNOPROTO BSD    { int poll(struct pollfd *fds, u_int nfds, \
 324                             int timeout); }
 325
 326 ;
 327 ; The following are reserved for loadable syscalls
 328 ;
 329 210     UNIMPL  NOHIDE
 330 211     UNIMPL  NOHIDE
 331 212     UNIMPL  NOHIDE
 332 213     UNIMPL  NOHIDE
 333 214     UNIMPL  NOHIDE
 334 215     UNIMPL  NOHIDE
 335 216     UNIMPL  NOHIDE
 336 217     UNIMPL  NOHIDE
 337 218     UNIMPL  NOHIDE
 338 219     UNIMPL  NOHIDE
 339
 340 ;
 341 ; The following were introduced with NetBSD/4.4Lite-2
 342 ; They are initialized by thier respective modules/sysinits
 343 220     MNOPROTO        BSD     { int __semctl(int semid, int semnum, int cmd, \
 344                             union semun *arg); }
 345 221     MNOPROTO        BSD     { int semget(key_t key, int nsems, int semflg); }
 346 222     MNOPROTO        BSD     { int semop(int semid, struct sembuf *sops, \
 347                             u_int nsops); }
 348 223     UNIMPL  NOHIDE  semconfig
 349 224     MNOPROTO        BSD     { int msgctl(int msqid, int cmd, \
 350                             struct msqid_ds *buf); }
 351 225     MNOPROTO        BSD     { int msgget(key_t key, int msgflg); }
 352 226     MNOPROTO        BSD     { int msgsnd(int msqid, void *msgp, size_t msgsz, \
 353                             int msgflg); }
 354 227     MNOPROTO        BSD     { int msgrcv(int msqid, void *msgp, size_t msgsz, \
 355                             long msgtyp, int msgflg); }
 356 228     MNOPROTO        BSD     { int shmat(int shmid, void *shmaddr, int shmflg); }
 357 229     MNOPROTO        BSD     { int shmctl(int shmid, int cmd, \
 358                             struct shmid_ds *buf); }
 359 230     MNOPROTO        BSD     { int shmdt(void *shmaddr); }
 360 231     MNOPROTO        BSD     { int shmget(key_t key, int size, int shmflg); }
 361 ;
 362 232     MNOPROTO POSIX  { int clock_gettime(clockid_t clock_id, \
 363                             struct timespec *tp); }
 364 233     MNOPROTO POSIX  { int clock_settime(clockid_t clock_id, \
 365                             const struct timespec *tp); }
 366 234     MNOPROTO POSIX  { int clock_getres(clockid_t clock_id, \
 367                             struct timespec *tp); }
 368 235     UNIMPL  NOHIDE  timer_create
 369 236     UNIMPL  NOHIDE  timer_delete
 370 237     UNIMPL  NOHIDE  timer_settime
 371 238     UNIMPL  NOHIDE  timer_gettime
 372 239     UNIMPL  NOHIDE  timer_getoverrun
 373 240     MNOPROTO POSIX  { int nanosleep(const struct timespec *rqtp, \
 374                             struct timespec *rmtp); }
 375 241     UNIMPL  NOHIDE  nosys
 376 242     UNIMPL  NOHIDE  nosys
 377 243     UNIMPL  NOHIDE  nosys
 378 244     UNIMPL  NOHIDE  nosys
 379 245     UNIMPL  NOHIDE  nosys
 380 246     UNIMPL  NOHIDE  nosys
 381 247     UNIMPL  NOHIDE  nosys
 382 248     UNIMPL  NOHIDE  nosys
 383 249     UNIMPL  NOHIDE  nosys
 384 ; syscall numbers initially used in OpenBSD
 385 250     MNOPROTO BSD    { int minherit(void *addr, size_t len, int inherit); }
 386 251     MNOPROTO BSD    { int rfork(int flags); }
 387 252     MNOPROTO BSD    { int openbsd_poll(struct pollfd *fds, u_int nfds, \
 388                             int timeout); }
 389 253     NOPROTO BSD     { int issetugid(void); }
 390 254     NOPROTO BSD     { int lchown(char *path, int uid, int gid); }
 391 255     UNIMPL  NOHIDE  nosys
 392 256     UNIMPL  NOHIDE  nosys
 393 257     UNIMPL  NOHIDE  nosys
 394 258     UNIMPL  NOHIDE  nosys
 395 259     UNIMPL  NOHIDE  nosys
 396 260     UNIMPL  NOHIDE  nosys
 397 261     UNIMPL  NOHIDE  nosys
 398 262     UNIMPL  NOHIDE  nosys
 399 263     UNIMPL  NOHIDE  nosys
 400 264     UNIMPL  NOHIDE  nosys
 401 265     UNIMPL  NOHIDE  nosys
 402 266     UNIMPL  NOHIDE  nosys
 403 267     UNIMPL  NOHIDE  nosys
 404 268     UNIMPL  NOHIDE  nosys
 405 269     UNIMPL  NOHIDE  nosys
 406 270     UNIMPL  NOHIDE  nosys
 407 271     UNIMPL  NOHIDE  nosys
 408 272     NOPROTO BSD     { int getdents(int fd, char *buf, size_t count); }
 409 273     UNIMPL  NOHIDE  nosys
 410 274     NOPROTO BSD     { int lchmod(char *path, mode_t mode); }
 411 275     NOPROTO BSD     { int lchown(char *path, uid_t uid, gid_t gid); } netbsd_lchown lchown_args int
 412 276     NOPROTO BSD     { int lutimes(char *path, struct timeval *tptr); }
 413 277     MNOPROTO BSD    { int msync(void *addr, size_t len, int flags); } netbsd_msync msync_args int
 414 278     NOPROTO BSD     { int nstat(char *path, struct nstat *ub); }
 415 279     MNOPROTO BSD    { int nfstat(int fd, struct nstat *sb); }
 416 280     NOPROTO BSD     { int nlstat(char *path, struct nstat *ub); }
 417 281     UNIMPL  NOHIDE  nosys
 418 282     UNIMPL  NOHIDE  nosys
 419 283     UNIMPL  NOHIDE  nosys
 420 284     UNIMPL  NOHIDE  nosys
 421 285     UNIMPL  NOHIDE  nosys
 422 286     UNIMPL  NOHIDE  nosys
 423 287     UNIMPL  NOHIDE  nosys
 424 288     UNIMPL  NOHIDE  nosys
 425 289     UNIMPL  NOHIDE  nosys
 426 290     UNIMPL  NOHIDE  nosys
 427 291     UNIMPL  NOHIDE  nosys
 428 292     UNIMPL  NOHIDE  nosys
 429 293     UNIMPL  NOHIDE  nosys
 430 294     UNIMPL  NOHIDE  nosys
 431 295     UNIMPL  NOHIDE  nosys
 432 296     UNIMPL  NOHIDE  nosys
 433 ; XXX 297 is 300 in NetBSD
 434 297     NOPROTO BSD     { int fhstatfs(const struct fhandle *u_fhp, struct statfs *buf); }
 435 298     NOPROTO BSD     { int fhopen(const struct fhandle *u_fhp, int flags); }
 436 299     NOPROTO BSD     { int fhstat(const struct fhandle *u_fhp, struct stat *sb); }
 437 ; syscall numbers for FreeBSD
 438 300     MNOPROTO BSD    { int modnext(int modid); }
 439 301     MNOPROTO BSD    { int modstat(int modid, struct module_stat* stat); }
 440 302     MNOPROTO BSD    { int modfnext(int modid); }
 441 303     MNOPROTO BSD    { int modfind(const char *name); }
 442 304     MNOPROTO BSD    { int kldload(const char *file); }
 443 305     MNOPROTO BSD    { int kldunload(int fileid); }
 444 306     MNOPROTO BSD    { int kldfind(const char *file); }
 445 307     MNOPROTO BSD    { int kldnext(int fileid); }
 446 308     MNOPROTO BSD    { int kldstat(int fileid, struct kld_file_stat* stat); }
 447 309     MNOPROTO BSD    { int kldfirstmod(int fileid); }
 448 310     MNOPROTO BSD    { int getsid(pid_t pid); }
 449 311     MNOPROTO BSD    { int setresuid(uid_t ruid, uid_t euid, uid_t suid); }
 450 312     MNOPROTO BSD    { int setresgid(gid_t rgid, gid_t egid, gid_t sgid); }
 451 313     OBSOL   NOHIDE  signanosleep
 452 314     UNIMPL  NOHIDE  aio_return
 453 315     UNIMPL  NOHIDE  aio_suspend
 454 316     UNIMPL  NOHIDE  aio_cancel
 455 317     UNIMPL  NOHIDE  aio_error
 456 318     UNIMPL  NOHIDE  aio_read
 457 319     UNIMPL  NOHIDE  aio_write
 458 320     UNIMPL  NOHIDE  lio_listio
 459 321     MNOPROTO BSD    { int yield(void); }
 460 322     OBSOL   NOHIDE  thr_sleep
 461 323     OBSOL   NOHIDE  thr_wakeup
 462 324     MNOPROTO BSD    { int mlockall(int how); }
 463 325     MNOPROTO BSD    { int munlockall(void); }
 464 326     NOPROTO BSD     { int __getcwd(u_char *buf, u_int buflen); }
 465
 466 327     MNOPROTO POSIX  { int sched_setparam (pid_t pid, const struct sched_param *param); }
 467 328     MNOPROTO POSIX  { int sched_getparam (pid_t pid, struct sched_param *param); }
 468
 469 329     MNOPROTO POSIX  { int sched_setscheduler (pid_t pid, int policy, const struct sched_param *param); }
 470 330     MNOPROTO POSIX  { int sched_getscheduler (pid_t pid); }
 471
 472 331     MNOPROTO POSIX  { int sched_yield (void); }
 473 332     MNOPROTO POSIX  { int sched_get_priority_max (int policy); }
 474 333     MNOPROTO POSIX  { int sched_get_priority_min (int policy); }
 475 334     MNOPROTO POSIX  { int sched_rr_get_interval (pid_t pid, struct timespec *interval); }
 476 335     NOPROTO BSD     { int utrace(const void *addr, size_t len); }
 477 ; XXX note - bigendian is different
 478 336     MCOMPAT4 BSD    { int ia32_sendfile(int fd, int s, u_int32_t offsetlo,\
 479                             u_int32_t offsethi, size_t nbytes, \
 480                             struct sf_hdtr *hdtr, off_t *sbytes, int flags); }
 481 337     NOPROTO BSD     { int kldsym(int fileid, int cmd, void *data); }
 482 338     MNOPROTO BSD    { int jail(struct jail *jail); }
 483 339     UNIMPL  BSD     pioctl
 484 340     MNOPROTO POSIX  { int sigprocmask(int how, const sigset_t *set, \
 485                             sigset_t *oset); }
 486 341     MNOPROTO POSIX  { int sigsuspend(const sigset_t *sigmask); }
 487 342     STD POSIX       { int ia32_sigaction(int sig, \
 488                             struct sigaction32 *act, \
 489                             struct sigaction32 *oact); }
 490 343     MNOPROTO POSIX  { int sigpending(sigset_t *set); }
 491 344     MNOPROTO BSD    { int sigreturn(const struct __ucontext *sigcntxp); }
 492 345     UNIMPL  NOHIDE  sigtimedwait
 493 346     UNIMPL  NOHIDE  sigwaitinfo
 494 347     MNOPROTO BSD    { int __acl_get_file(const char *path, \
 495                             acl_type_t type, struct acl *aclp); }
 496 348     MNOPROTO BSD    { int __acl_set_file(const char *path, \
 497                             acl_type_t type, struct acl *aclp); }
 498 349     MNOPROTO BSD    { int __acl_get_fd(int filedes, acl_type_t type, \
 499                             struct acl *aclp); }
 500 350     MNOPROTO BSD    { int __acl_set_fd(int filedes, acl_type_t type, \
 501                             struct acl *aclp); }
 502 351     MNOPROTO BSD    { int __acl_delete_file(const char *path, \
 503                             acl_type_t type); }
 504 352     MNOPROTO BSD    { int __acl_delete_fd(int filedes, acl_type_t type); }
 505 353     MNOPROTO BSD    { int __acl_aclcheck_file(const char *path, \
 506                             acl_type_t type, struct acl *aclp); }
 507 354     MNOPROTO BSD    { int __acl_aclcheck_fd(int filedes, acl_type_t type, \
 508                             struct acl *aclp); }
 509 355     NOPROTO BSD     { int extattrctl(const char *path, int cmd, \
 510                             const char *filename, int attrnamespace, \
 511                             const char *attrname); }
 512 356     NOPROTO BSD     { int extattr_set_file(const char *path, \
 513                             int attrnamespace, const char *attrname, \
 514                             void *data, size_t nbytes); }
 515 357     NOPROTO BSD     { ssize_t extattr_get_file(const char *path, \
 516                             int attrnamespace, const char *attrname, \
 517                             void *data, size_t nbytes); }
 518 358     NOPROTO BSD     { int extattr_delete_file(const char *path, \
 519                             int attrnamespace, const char *attrname); }
 520 359     UNIMPL  NOHIDE  aio_waitcomplete
 521 360     MNOPROTO BSD    { int getresuid(uid_t *ruid, uid_t *euid, uid_t *suid); }
 522 361     MNOPROTO BSD    { int getresgid(gid_t *rgid, gid_t *egid, gid_t *sgid); }
 523 362     MNOPROTO BSD    { int kqueue(void); }
 524 363     MNOPROTO BSD    { int kevent(int fd, \
 525                             const struct kevent *changelist, int nchanges, \
 526                             struct kevent *eventlist, int nevents, \
 527                             const struct timespec *timeout); }
 528 364     UNIMPL  NOHIDE  __cap_get_proc
 529 365     UNIMPL  NOHIDE  __cap_set_proc
 530 366     UNIMPL  NOHIDE  __cap_get_fd
 531 367     UNIMPL  NOHIDE  __cap_get_file
 532 368     UNIMPL  NOHIDE  __cap_set_fd
 533 369     UNIMPL  NOHIDE  __cap_set_file
 534 370     UNIMPL  NOHIDE  lkmressys
 535 371     NOPROTO BSD     { int extattr_set_fd(int fd, int attrnamespace, \
 536                             const char *attrname, void *data, \
 537                             size_t nbytes); }
 538 372     NOPROTO BSD     { ssize_t extattr_get_fd(int fd, int attrnamespace, \
 539                             const char *attrname, void *data, size_t nbytes); }
 540 373     NOPROTO BSD     { int extattr_delete_fd(int fd, int attrnamespace, \
 541                             const char *attrname); }
 542 374     MNOPROTO BSD    { int __setugid(int flag); }
 543 375     UNIMPL  BSD     nfsclnt
 544 376     NOPROTO BSD     { int eaccess(char *path, int flags); }
 545 377     UNIMPL  BSD     afs_syscall
 546 378     NOPROTO BSD     { int nmount(struct iovec *iovp, unsigned int iovcnt, \
 547                             int flags); }
 548 379     NOPROTO BSD     { int kse_exit(void); }
 549 380     NOPROTO BSD     { int kse_wakeup(struct kse_mailbox *mbx); }
 550 381     NOPROTO BSD     { int kse_create(struct kse_mailbox *mbx, \
 551                             int newgroup); }
 552 382     NOPROTO BSD     { int kse_thr_interrupt(struct kse_thr_mailbox *tmbx); }
 553 383     NOPROTO BSD     { int kse_release(void); }
 554 384     UNIMPL  BSD     __mac_get_proc
 555 385     UNIMPL  BSD     __mac_set_proc
 556 386     UNIMPL  BSD     __mac_get_fd
 557 387     UNIMPL  BSD     __mac_get_file
 558 388     UNIMPL  BSD     __mac_set_fd
 559 389     UNIMPL  BSD     __mac_set_file
 560 390     NOPROTO BSD     { int kenv(int what, const char *name, char *value, \
 561                             int len); }
 562 391     NOPROTO BSD     { int lchflags(const char *path, int flags); }
 563 392     NOPROTO BSD     { int uuidgen(struct uuid *store, int count); }
 564 393     MSTD    BSD     { int ia32_sendfile(int fd, int s, u_int32_t offsetlo, \
 565                             u_int32_t offsethi, size_t nbytes, \
 566                             struct sf_hdtr *hdtr, off_t *sbytes, int flags); }
 567 394     UNIMPL  NOHIDE  mac_syscall
 568 395     UNIMPL  NOHIDE  nosys
 569 396     UNIMPL  NOHIDE  nosys
 570 397     UNIMPL  NOHIDE  nosys
 571 398     UNIMPL  NOHIDE  nosys
 572 399     UNIMPL  NOHIDE  nosys
 573 400     UNIMPL  NOHIDE  ksem_close
 574 401     UNIMPL  NOHIDE  ksem_post
 575 402     UNIMPL  NOHIDE  ksem_wait
 576 403     UNIMPL  NOHIDE  ksem_trywait
 577 404     UNIMPL  NOHIDE  ksem_init
 578 405     UNIMPL  NOHIDE  ksem_open
 579 406     UNIMPL  NOHIDE  ksem_unlink
 580 407     UNIMPL  NOHIDE  ksem_getvalue
 581 408     UNIMPL  NOHIDE  ksem_destroy
 582 409     UNIMPL  BSD     __mac_get_pid
 583 410     UNIMPL  BSD     __mac_get_link
 584 411     UNIMPL  BSD     __mac_set_link
 585 412     UNIMPL  BSD     extattr_set_link
 586 413     UNIMPL  BSD     extattr_get_link
 587 414     UNIMPL  BSD     extattr_delete_link
 588 415     UNIMPL  BSD     __mac_execve
 589 416     UNIMPL  BSD     newsigreturn
 590 417     UNIMPL  BSD     newsigaction
 591 418     UNIMPL  BSD     __xstat
 592 419     UNIMPL  BSD     __xfstat
 593 420     UNIMPL  BSD     __xlstat
 594 421     UNIMPL  BSD     getcontext
 595 422     UNIMPL  BSD     setcontext
 596 423     UNIMPL  BSD     swapcontext