FreeBSD/Linux Kernel Cross Reference
sys/kern/syscalls.master

      $FreeBSD$
     ;       from: @(#)syscalls.master       8.2 (Berkeley) 1/13/94
     ;
     ; System call name/number master file.
     ; Processed to created init_sysent.c, syscalls.c and syscall.h.
     
     ; New FreeBSD system calls should be added to the bottom of this file.
     
     ; Columns: number audit type name alt{name,tag,rtyp}/comments
    ;       number  system call number, must be in order
    ;       audit   the audit event associated with the system call
    ;               A value of AUE_NULL means no auditing, but it also means that
    ;               there is no audit event for the call at this time. For the
    ;               case where the event exists, but we don't want auditing, the
    ;               event should be #defined to AUE_NULL in audit_kevents.h.
    ;       type    one of STD, OBSOL, RESERVED, UNIMPL, SYSMUX, COMPAT*,
    ;               NODEF, NOARGS, NOPROTO, NOSTD
    ;               The COMPAT* options may be combined with one or more NO*
    ;               options separated by '|' with no spaces (e.g. COMPAT|NOARGS)
    ;               The CAPENABLED option may be ORed into a type.
    ;       name    pseudo-prototype of syscall routine
    ;               If one of the following alts is different, then all appear:
    ;       altname name of system call if different
    ;       alttag  name of args struct tag if different from [o]`name'"_args"
    ;       altrtyp return type if not int (bogus - syscalls always return int)
    ;               for UNIMPL/OBSOL, name continues with comments
    
    ; types:
    ;       STD     always included
    ;       COMPAT  included on COMPAT #ifdef
    ;       COMPAT4 included on COMPAT_FREEBSD4 #ifdef (FreeBSD 4 compat)
    ;       COMPAT6 included on COMPAT_FREEBSD6 #ifdef (FreeBSD 6 compat)
    ;       COMPAT7 included on COMPAT_FREEBSD7 #ifdef (FreeBSD 7 compat)
    ;       COMPAT10 included on COMPAT_FREEBSD10 #ifdef (FreeBSD 10 compat)
    ;       COMPAT11 included on COMPAT_FREEBSD11 #ifdef (FreeBSD 11 compat)
    ;       COMPAT12 included on COMPAT_FREEBSD12 #ifdef (FreeBSD 12 compat)
    ;       COMPAT13 included on COMPAT_FREEBSD13 #ifdef (FreeBSD 13 compat)
    ;       OBSOL   obsolete, not included in system, only specifies name
    ;       RESERVED reserved for local or vendor use (not for FreeBSD)
    ;       UNIMPL  not implemented, placeholder only
    ;       NOSTD   implemented but as a lkm that can be statically
    ;               compiled in; sysent entry will be filled with lkmressys
    ;               so the SYSCALL_MODULE macro works
    ;       NOARGS  same as STD except do not create structure in sys/sysproto.h
    ;       NODEF   same as STD except only have the entry in the syscall table
    ;               added.  Meaning - do not create structure or function
    ;               prototype in sys/sysproto.h
    ;       NOPROTO same as STD except do not create structure or
    ;               function prototype in sys/sysproto.h.  Does add a
    ;               definition to syscall.h besides adding a sysent.
    ;       NOTSTATIC syscall is loadable
    ;       SYSMUX  syscall multiplexer.  No prototype, argument struct, or
    ;               handler is declared or used.  Handled in MD syscall code.
    ;       CAPENABLED syscall is allowed in capability mode
    ;
    ; To support programmatic generation of both the default ABI and 32-bit compat
    ; (freebsd32) we impose a number of restrictions on the types of system calls.
    ; For integer types:
    ;  - Bare int and long are allowed (long is a sign of a bad interface).
    ;  - Use u_int and u_long rather than "unsigned (int|long)".
    ;  - size_t is allowed.
    ;  - typedefs are allowed, but new signed types that vary between 32- and
    ;    64-bit ABIs must be added to makesyscalls.lua so it knows they require
    ;    handling.
    ;  - Always-64-bit types other than dev_t, id_t, and off_t must be added to
    ;    makesyscalls.lua.
    ; For pointers:
    ;  - Prefer structs to typedefs so an ABI-specific suffix (e.g., "32") can
    ;    be prepended (e.g., ucontext_t -> struct ucontext -> struct ucontext32).
    ;  - Pointers to objects (structs, unions, etc) containing any long, pointer,
    ;    or time_t arguments need _Contains_ annotations.  Such objects should be
    ;    padded such that all 64-bit types are 64-bit aligned.
    
    ; annotations:
    ;       SAL 2.0 annotations are used to specify how system calls treat
    ;       arguments that are passed using pointers. There are three basic
    ;       annotations.
    ;
    ;       _In_    Object pointed to will be read and not modified.
    ;       _Out_   Object pointed to will be written and not read.
    ;       _Inout_ Object pointed to will be written and read.
    ;
    ;       These annotations are used alone when the pointer refers to a single
    ;       object i.e. scalar types, structs, and pointers, and not NULL. Adding
    ;       the _opt_ suffix, e.g. _In_opt_, implies that the pointer may also
    ;       refer to NULL.
    ;
    ;       For pointers to arrays, additional suffixes are added:
    ;
    ;       _In_z_, _Out_z_, _Inout_z_:
    ;           for a NUL terminated array e.g. a string.
    ;       _In_reads_z_(n),_Out_writes_z_(n), _Inout_updates_z_(n):
    ;           for a NUL terminated array e.g. a string, of known length n bytes.
    ;       _In_reads_(n),_Out_writes_(n),_Inout_updates_(n):
    ;           for an array of n elements.
    ;       _In_reads_bytes_(n), _Out_writes_bytes_(n), _Inout_updates_bytes(n):
    ;           for a buffer of n-bytes.
    ;
    ;       In addition to SAL annotations, pointers are annotated to indicate
   ;       that they point to types that change between ABIs.  That means that
   ;       they contain long, pointer, or time_t types.  This is indicated with
   ;       a _Contains_ annotation followed immediately by one or more of:
   ;
   ;       long_   Object contains a direct (or typedef'd) long value and varies
   ;               between 32- and 64-bit ABIs.  This includes size_t.
   ;       ptr_    Object contains pointers (or intptr_t) and varies between
   ;               32- and 64-bit ABIs.
   ;       timet_  Object contains a time_t and varies between i386 and other
   ;               ABIs.
   
   ; #ifdef's, etc. may be included, and are copied to the output files.
   
   #include <sys/param.h>
   #include <sys/sysent.h>
   #include <sys/sysproto.h>
   %%ABI_HEADERS%%
   
   0       AUE_NULL        SYSMUX {
                   int syscall(
                       int number,
                       ...
                   );
           }
   1       AUE_EXIT        STD|CAPENABLED {
                   void exit(
                       int rval
                   );
           }
   2       AUE_FORK        STD|CAPENABLED {
                   int fork(void);
           }
   3       AUE_READ        STD|CAPENABLED {
                   ssize_t read(
                       int fd,
                       _Out_writes_bytes_(nbyte) void *buf,
                       size_t nbyte
                   );
           }
   4       AUE_WRITE       STD|CAPENABLED {
                   ssize_t write(
                       int fd,
                       _In_reads_bytes_(nbyte) const void *buf,
                       size_t nbyte
                   );
           }
   5       AUE_OPEN_RWTC   STD {
                   int open(
                       _In_z_ const char *path,
                       int flags,
                       mode_t mode
                   );
           }
   ; XXX should be         { int open(const char *path, int flags, ...); }
   ; but we're not ready for varargs.
   6       AUE_CLOSE       STD|CAPENABLED {
                   int close(
                       int fd
                   );
           }
   7       AUE_WAIT4       STD {
                   int wait4(
                       int pid,
                       _Out_opt_ int *status,
                       int options,
                       _Out_opt_ _Contains_long_timet_ struct rusage *rusage
                   );
           }
   8       AUE_CREAT       COMPAT {
                   int creat(
                       _In_z_ const char *path,
                       int mode
                   );
           }
   9       AUE_LINK        STD {
                   int link(
                       _In_z_ const char *path,
                       _In_z_ const char *link
                   );
           }
   10      AUE_UNLINK      STD {
                   int unlink(
                       _In_z_ const char *path
                   );
           }
   11      AUE_NULL        OBSOL   execv
   12      AUE_CHDIR       STD {
                   int chdir(
                       _In_z_ const char *path
                   );
           }
   13      AUE_FCHDIR      STD {
                   int fchdir(
                       int fd
                   );
           }
   14      AUE_MKNOD       COMPAT11 {
                   int mknod(
                       _In_z_ const char *path,
                       int mode,
                       uint32_t dev
                   );
           }
   15      AUE_CHMOD       STD {
                   int chmod(
                       _In_z_ const char *path,
                       mode_t mode
                   );
           }
   16      AUE_CHOWN       STD {
                   int chown(
                       _In_z_ const char *path,
                       int uid,
                       int gid
                   );
           }
   17      AUE_NULL        STD|CAPENABLED {
                   void *break(
                       _In_ char *nsize
                   );
           }
   18      AUE_GETFSSTAT   COMPAT4 {
                   int getfsstat(
                       _Out_writes_bytes_opt_(bufsize) _Contains_long_ struct ostatfs *buf,
                       long bufsize,
                       int mode
                   );
           }
   19      AUE_LSEEK       COMPAT|CAPENABLED {
                   long lseek(
                       int fd,
                       long offset,
                       int whence
                   );
           }
   20      AUE_GETPID      STD|CAPENABLED {
                   pid_t getpid(void);
           }
   21      AUE_MOUNT       STD {
                   int mount(
                       _In_z_ const char *type,
                       _In_z_ const char *path,
                       int flags,
                       _In_opt_ void *data
                   );
           }
   22      AUE_UMOUNT      STD {
                   int unmount(
                       _In_z_ const char *path,
                       int flags
                   );
           }
   23      AUE_SETUID      STD|CAPENABLED {
                   int setuid(
                       uid_t uid
                   );
           }
   24      AUE_GETUID      STD|CAPENABLED {
                   uid_t getuid(void);
           }
   25      AUE_GETEUID     STD|CAPENABLED {
                   uid_t geteuid(void);
           }
   26      AUE_PTRACE      STD {
                   int ptrace(
                       int req,
                       pid_t pid,
                       _Inout_opt_ _Contains_long_ptr_ caddr_t addr,
                       int data
                   );
           }
   27      AUE_RECVMSG     STD|CAPENABLED {
                   ssize_t recvmsg(
                       int s,
                       _Inout_ _Contains_ptr_ struct msghdr *msg,
                       int flags
                   );
           }
   28      AUE_SENDMSG     STD|CAPENABLED {
                   ssize_t sendmsg(
                       int s,
                       _In_ _Contains_ptr_ const struct msghdr *msg,
                       int flags
                   );
           }
   29      AUE_RECVFROM    STD|CAPENABLED {
                   ssize_t recvfrom(
                       int s,
                       _Out_writes_bytes_(len) void *buf,
                       size_t len,
                       int flags,
                       _Out_writes_bytes_opt_(*fromlenaddr) struct sockaddr *from,
                       _Inout_opt_ __socklen_t *fromlenaddr
                   );
           }
   30      AUE_ACCEPT      STD|CAPENABLED {
                   int accept(
                       int s,
                       _Out_writes_bytes_opt_(*anamelen) struct sockaddr *name,
                       _Inout_opt_ __socklen_t *anamelen
                   );
           }
   31      AUE_GETPEERNAME STD|CAPENABLED {
                   int getpeername(
                       int fdes,
                       _Out_writes_bytes_(*alen) struct sockaddr *asa,
                       _Inout_opt_ __socklen_t *alen
                   );
           }
   32      AUE_GETSOCKNAME STD|CAPENABLED {
                   int getsockname(
                       int fdes,
                       _Out_writes_bytes_(*alen) struct sockaddr *asa,
                       _Inout_ __socklen_t *alen
                   );
           }
   33      AUE_ACCESS      STD {
                   int access(
                       _In_z_ const char *path,
                       int amode
                   );
           }
   34      AUE_CHFLAGS     STD {
                   int chflags(
                       _In_z_ const char *path,
                       u_long flags
                   );
           }
   35      AUE_FCHFLAGS    STD|CAPENABLED {
                   int fchflags(
                       int fd,
                       u_long flags
                   );
           }
   36      AUE_SYNC        STD|CAPENABLED {
                   int sync(void);
           }
   37      AUE_KILL        STD|CAPENABLED {
                   int kill(
                       int pid,
                       int signum
                   );
           }
   38      AUE_STAT        COMPAT {
                   int stat(
                       _In_z_ const char *path,
                       _Out_ _Contains_timet_ struct ostat *ub
                   );
           }
   39      AUE_GETPPID     STD|CAPENABLED {
                   pid_t getppid(void);
           }
   40      AUE_LSTAT       COMPAT {
                   int lstat(
                       _In_z_ const char *path,
                       _Out_ _Contains_timet_ struct ostat *ub
                   );
           }
   41      AUE_DUP         STD|CAPENABLED {
                   int dup(
                       u_int fd
                   );
           }
   42      AUE_PIPE        COMPAT10|CAPENABLED {
                   int pipe(void);
           }
   43      AUE_GETEGID     STD|CAPENABLED {
                   gid_t getegid(void);
           }
   44      AUE_PROFILE     STD|CAPENABLED {
                   int profil(
                       _Out_writes_bytes_(size) char *samples,
                       size_t size,
                       size_t offset,
                       u_int scale
                   );
           }
   45      AUE_KTRACE      STD {
                   int ktrace(
                       _In_z_ const char *fname,
                       int ops,
                       int facs,
                       int pid
                   );
           }
   46      AUE_SIGACTION   COMPAT|CAPENABLED {
                   int sigaction(
                       int signum,
                       _In_opt_ _Contains_ptr_ struct osigaction *nsa,
                       _Out_opt_ _Contains_ptr_ struct osigaction *osa
                   );
           }
   47      AUE_GETGID      STD|CAPENABLED {
                   gid_t getgid(void);
           }
   48      AUE_SIGPROCMASK COMPAT|CAPENABLED {
                   int sigprocmask(
                       int how,
                       osigset_t mask
                   );
           }
   ; XXX note nonstandard (bogus) calling convention - the libc stub passes
   ; us the mask, not a pointer to it, and we return the old mask as the
   ; (int) return value.
   49      AUE_GETLOGIN    STD|CAPENABLED {
                   int getlogin(
                       _Out_writes_z_(namelen) char *namebuf,
                       u_int namelen
                   );
           }
   50      AUE_SETLOGIN    STD {
                   int setlogin(
                       _In_z_ const char *namebuf
                   );
           }
   51      AUE_ACCT        STD {
                   int acct(
                       _In_z_ const char *path
                   );
           }
   52      AUE_SIGPENDING  COMPAT|CAPENABLED {
                   int sigpending(void);
           }
   53      AUE_SIGALTSTACK STD|CAPENABLED {
                   int sigaltstack(
                       _In_opt_ _Contains_long_ptr_ const struct sigaltstack *ss,
                       _Out_opt_ _Contains_long_ptr_ struct sigaltstack *oss
                   );
           }
   54      AUE_IOCTL       STD|CAPENABLED {
                   int ioctl(
                       int fd,
                       u_long com,
                       _Inout_opt_ _Contains_long_ptr_ char *data
                   );
           }
   55      AUE_REBOOT      STD {
                   int reboot(
                       int opt
                   );
           }
   56      AUE_REVOKE      STD {
                   int revoke(
                       _In_z_ const char *path
                   );
           }
   57      AUE_SYMLINK     STD {
                   int symlink(
                       _In_z_ const char *path,
                       _In_z_ const char *link
                   );
           }
   58      AUE_READLINK    STD {
                   ssize_t readlink(
                       _In_z_ const char *path,
                       _Out_writes_z_(count) char *buf,
                       size_t count
                   );
           }
   59      AUE_EXECVE      STD {
                   int execve(
                       _In_z_ const char *fname,
                       _In_z_ char **argv,
                       _In_z_ char **envv
                   );
           }
   60      AUE_UMASK       STD|CAPENABLED {
                   mode_t umask(
                       mode_t newmask
                   );
           }
   61      AUE_CHROOT      STD {
                   int chroot(
                       _In_z_ const char *path
                   );
           }
   62      AUE_FSTAT       COMPAT|CAPENABLED {
                   int fstat(
                       int fd,
                       _Out_ _Contains_timet_ struct ostat *sb
                   );
           }
   63      AUE_NULL        COMPAT {
                   int getkerninfo(
                       int op,
                       _Out_writes_bytes_opt(*size) char *where,
                       _Inout_opt_ size_t *size,
                       int arg
                   );
           }
   64      AUE_NULL        COMPAT|CAPENABLED {
                   int getpagesize(void);
           }
   65      AUE_MSYNC       STD|CAPENABLED {
                   int msync(
                       _In_ void *addr,
                       size_t len,
                       int flags
                   );
           }
   66      AUE_VFORK       STD {
                   int vfork(void);
           }
   67      AUE_NULL        OBSOL   vread
   68      AUE_NULL        OBSOL   vwrite
   69      AUE_SBRK        STD|CAPENABLED {
                   int sbrk(
                       int incr
                   );
           }
   70      AUE_SSTK        STD|CAPENABLED {
                   int sstk(
                       int incr
                   );
           }
   71      AUE_MMAP        COMPAT|CAPENABLED {
                   void *mmap(
                       _In_ void *addr,
                       int len,
                       int prot,
                       int flags,
                       int fd,
                       long pos
                   );
           }
   72      AUE_O_VADVISE   COMPAT11 {
                   int vadvise(
                       int anom
                   );
           }
   73      AUE_MUNMAP      STD|CAPENABLED {
                   int munmap(
                       _In_ void *addr,
                       size_t len
                   );
           }
   74      AUE_MPROTECT    STD|CAPENABLED {
                   int mprotect(
                       _In_ void *addr,
                       size_t len,
                       int prot
                   );
           }
   75      AUE_MADVISE     STD|CAPENABLED {
                   int madvise(
                       _In_ void *addr,
                       size_t len,
                       int behav
                   );
           }
   76      AUE_NULL        OBSOL   vhangup
   77      AUE_NULL        OBSOL   vlimit
   78      AUE_MINCORE     STD|CAPENABLED {
                   int mincore(
                       _In_ const void *addr,
                       size_t len,
                       _Out_writes_bytes_(len/PAGE_SIZE) char *vec
                   );
           }
   79      AUE_GETGROUPS   STD|CAPENABLED {
                   int getgroups(
                       int gidsetsize,
                       _Out_writes_opt_(gidsetsize) gid_t *gidset
                   );
           }
   80      AUE_SETGROUPS   STD {
                   int setgroups(
                       int gidsetsize,
                       _In_reads_(gidsetsize) const gid_t *gidset
                   );
           }
   81      AUE_GETPGRP     STD|CAPENABLED {
                   int getpgrp(void);
           }
   82      AUE_SETPGRP     STD {
                   int setpgid(
                       int pid,
                       int pgid
                   );
           }
   83      AUE_SETITIMER   STD|CAPENABLED {
                   int setitimer(
                       int which,
                       _In_ _Contains_timet_ const struct itimerval *itv,
                       _Out_opt_ _Contains_timet_ struct itimerval *oitv
                   );
           }
   84      AUE_WAIT4       COMPAT {
                   int wait(void);
           }
   85      AUE_SWAPON      STD {
                   int swapon(
                       _In_z_ const char *name
                   );
           }
   86      AUE_GETITIMER   STD|CAPENABLED {
                   int getitimer(
                       int which,
                       _Out_ _Contains_timet_ struct itimerval *itv
                   );
           }
   87      AUE_SYSCTL      COMPAT|CAPENABLED {
                   int gethostname(
                       _Out_writes_z_(len) char *hostname,
                       u_int len
                   );
           }
   88      AUE_SYSCTL      COMPAT {
                   int sethostname(
                       _In_reads_z_(len) char *hostname,
                       u_int len
                   );
           }
   89      AUE_GETDTABLESIZE       STD|CAPENABLED {
                   int getdtablesize(void);
           }
   90      AUE_DUP2        STD|CAPENABLED {
                   int dup2(
                       u_int from,
                       u_int to
                   );
           }
   91      AUE_NULL        RESERVED
   92      AUE_FCNTL       STD|CAPENABLED {
                   int fcntl(
                       int fd,
                       int cmd,
                       long arg
                   );
           }
   ; XXX should be { int fcntl(int fd, int cmd, ...); }
   ; but we're not ready for varargs.
   93      AUE_SELECT      STD|CAPENABLED {
                   int select(
                       int nd,
                       _Inout_opt_ fd_set *in,
                       _Inout_opt_ fd_set *ou,
                       _Inout_opt_ fd_set *ex,
                       _In_opt_ _Contains_long_timet_ struct timeval *tv
                   );
           }
   94      AUE_NULL        RESERVED
   95      AUE_FSYNC       STD|CAPENABLED {
                   int fsync(
                       int fd
                   );
           }
   96      AUE_SETPRIORITY STD|CAPENABLED {
                   int setpriority(
                       int which,
                       int who,
                       int prio
                   );
           }
   97      AUE_SOCKET      STD|CAPENABLED {
                   int socket(
                       int domain,
                       int type,
                       int protocol
                   );
           }
   98      AUE_CONNECT     STD {
                   int connect(
                       int s,
                       _In_reads_bytes_(namelen) const struct sockaddr *name,
                       __socklen_t namelen
                   );
           }
   99      AUE_ACCEPT      COMPAT|CAPENABLED {
                   int accept(
                       int s,
                       _Out_writes_bytes_opt_(*anamelen) struct sockaddr *name,
                       __socklen_t *anamelen
                   );
           }
   100     AUE_GETPRIORITY STD|CAPENABLED {
                   int getpriority(
                       int which,
                       int who
                   );
           }
   101     AUE_SEND        COMPAT|CAPENABLED {
                   int send(
                       int s,
                       _In_reads_bytes_(len) const void *buf,
                       int len,
                       int flags
                   );
           }
   102     AUE_RECV        COMPAT|CAPENABLED {
                   int recv(
                       int s,
                       _Out_writes_bytes_(len) void *buf,
                       int len,
                       int flags
                   );
           }
   103     AUE_SIGRETURN   COMPAT|CAPENABLED {
                   int sigreturn(
                       _In_ struct osigcontext *sigcntxp
                   );
           }
   104     AUE_BIND        STD {
                   int bind(
                       int s,
                       _In_reads_bytes_(namelen) const struct sockaddr *name,
                       __socklen_t namelen
                   );
           }
   105     AUE_SETSOCKOPT  STD|CAPENABLED {
                   int setsockopt(
                       int s,
                       int level,
                       int name,
                       _In_reads_bytes_opt_(valsize) const void *val,
                       __socklen_t valsize
                   );
           }
   106     AUE_LISTEN      STD|CAPENABLED {
                   int listen(
                       int s,
                       int backlog
                   );
           }
   107     AUE_NULL        OBSOL   vtimes
   108     AUE_NULL        COMPAT|CAPENABLED {
                   int sigvec(
                       int signum,
                       _In_opt_ _Contains_ptr_ struct sigvec *nsv,
                       _Out_opt_ _Contains_ptr_ struct sigvec *osv
                   );
           }
   109     AUE_NULL        COMPAT|CAPENABLED {
                   int sigblock(
                       int mask
                   );
           }
   110     AUE_NULL        COMPAT|CAPENABLED {
                   int sigsetmask(
                       int mask
                   );
           }
   111     AUE_NULL        COMPAT|CAPENABLED {
                   int sigsuspend(
                       osigset_t mask
                   );
           }
   ; XXX note nonstandard (bogus) calling convention - the libc stub passes
   ; us the mask, not a pointer to it.
   112     AUE_NULL        COMPAT|CAPENABLED {
                   int sigstack(
                       _In_opt_ _Contains_ptr_ struct sigstack *nss,
                       _Out_opt_ _Contains_ptr_ struct sigstack *oss
                   );
           }
   113     AUE_RECVMSG     COMPAT|CAPENABLED {
                   int recvmsg(
                       int s,
                       _Inout_ _Contains_ptr_ struct omsghdr *msg,
                       int flags
                   );
           }
   114     AUE_SENDMSG     COMPAT|CAPENABLED {
                   int sendmsg(
                       int s,
                       _In_ _Contains_ptr_ const struct omsghdr *msg,
                       int flags
                   );
           }
   115     AUE_NULL        OBSOL   vtrace
   116     AUE_GETTIMEOFDAY        STD|CAPENABLED {
                   int gettimeofday(
                       _Out_ _Contains_long_timet_ struct timeval *tp,
                       _Out_opt_ struct timezone *tzp
                   );
           }
   117     AUE_GETRUSAGE   STD|CAPENABLED {
                   int getrusage(
                       int who,
                       _Out_ _Contains_long_ struct rusage *rusage
                   );
           }
   118     AUE_GETSOCKOPT  STD|CAPENABLED {
                   int getsockopt(
                       int s,
                       int level,
                       int name,
                       _Out_writes_bytes_opt_(*avalsize) void *val,
                       _Inout_ __socklen_t *avalsize
                   );
           }
   119     AUE_NULL        RESERVED
   120     AUE_READV       STD|CAPENABLED {
                   int readv(
                       int fd,
                       _Inout_updates_(iovcnt) _Contains_long_ptr_ struct iovec *iovp,
                       u_int iovcnt
                   );
           }
   121     AUE_WRITEV      STD|CAPENABLED {
                   int writev(
                       int fd,
                       _In_reads_opt_(iovcnt) _Contains_long_ptr_ struct iovec *iovp,
                       u_int iovcnt
                   );
           }
   122     AUE_SETTIMEOFDAY        STD {
                   int settimeofday(
                       _In_ _Contains_long_timet_ const struct timeval *tv,
                       _In_opt_ const struct timezone *tzp
                   );
           }
   123     AUE_FCHOWN      STD|CAPENABLED {
                   int fchown(
                       int fd,
                       int uid,
                       int gid
                   );
           }
   124     AUE_FCHMOD      STD|CAPENABLED {
                   int fchmod(
                       int fd,
                       mode_t mode
                   );
           }
   125     AUE_RECVFROM    COMPAT|CAPENABLED {
                   int recvfrom(
                       int s,
                       _Out_writes_(len) void *buf,
                       size_t len,
                       int flags,
                       _Out_writes_bytes_(*fromlenaddr) struct sockaddr *from,
                       _Inout_ __socklen_t *fromlenaddr
                   );
           }
   126     AUE_SETREUID    STD|CAPENABLED {
                   int setreuid(
                       int ruid,
                       int euid
                   );
           }
   127     AUE_SETREGID    STD|CAPENABLED {
                   int setregid(
                       int rgid,
                       int egid
                   );
           }
   128     AUE_RENAME      STD {
                   int rename(
                       _In_z_ const char *from,
                       _In_z_ const char *to
                   );
           }
   129     AUE_TRUNCATE    COMPAT {
                   int truncate(
                       _In_z_ const char *path,
                       long length
                   );
           }
   130     AUE_FTRUNCATE   COMPAT|CAPENABLED {
                   int ftruncate(
                       int fd,
                       long length
                   );
           }
   131     AUE_FLOCK       STD|CAPENABLED {
                   int flock(
                       int fd,
                       int how
                   );
           }
   132     AUE_MKFIFO      STD {
                   int mkfifo(
                       _In_z_ const char *path,
                       mode_t mode
                   );
           }
   133     AUE_SENDTO      STD|CAPENABLED {
                   ssize_t sendto(
                       int s,
                       _In_reads_bytes_(len) const void *buf,
                       size_t len,
                       int flags,
                       _In_reads_bytes_opt_(tolen) const struct sockaddr *to,
                       __socklen_t tolen
                   );
           }
   134     AUE_SHUTDOWN    STD|CAPENABLED {
                   int shutdown(
                       int s,
                       int how
                   );
           }
   135     AUE_SOCKETPAIR  STD|CAPENABLED {
                   int socketpair(
                       int domain,
                       int type,
                       int protocol,
                       _Out_writes_(2) int *rsv
                   );
           }
   136     AUE_MKDIR       STD {
                   int mkdir(
                       _In_z_ const char *path,
                       mode_t mode
                   );
           }
   137     AUE_RMDIR       STD {
                   int rmdir(
                       _In_z_ const char *path
                   );
           }
   138     AUE_UTIMES      STD {
                   int utimes(
                       _In_z_ const char *path,
                       _In_ _Contains_long_timet_ const struct timeval *tptr
                   );
           }
   139     AUE_NULL        OBSOL   4.2 sigreturn
   140     AUE_ADJTIME     STD {
                   int adjtime(
                       _In_ _Contains_long_timet_ const struct timeval *delta,
                       _Out_opt_ _Contains_long_timet_ struct timeval *olddelta
                   );
           }
   141     AUE_GETPEERNAME COMPAT|CAPENABLED {
                   int getpeername(
                       int fdes,
                       _Out_writes_bytes_(*alen) struct sockaddr *asa,
                       _Inout_opt_ __socklen_t *alen
                   );
           }
   142     AUE_SYSCTL      COMPAT|CAPENABLED {
                   long gethostid(void);
           }
   143     AUE_SYSCTL      COMPAT {
                   int sethostid(
                       long hostid
                   );
           }
   144     AUE_GETRLIMIT   COMPAT|CAPENABLED {
                   int getrlimit(
                       u_int which,
                       _Out_ struct orlimit *rlp
                   );
           }
   145     AUE_SETRLIMIT   COMPAT|CAPENABLED {
                   int setrlimit(
                       u_int which,
                       _Out_ struct orlimit *rlp
                   );
           }
   146     AUE_KILLPG      COMPAT {
                   int killpg(
                       int pgid,
                       int signum
                   );
           }
   147     AUE_SETSID      STD|CAPENABLED {
                   int setsid(void);
           }
   148     AUE_QUOTACTL    STD {
                   int quotactl(
                       _In_z_ const char *path,
                       int cmd,
                       int uid,
                       _In_ void *arg
                   );
           }
   149     AUE_O_QUOTA     COMPAT {
                   int quota(void);
           }
   150     AUE_GETSOCKNAME COMPAT|CAPENABLED {
                   int getsockname(
                       int fdes,
                       _Out_writes_bytes_(*alen) struct sockaddr *asa,
                       _Inout_ __socklen_t *alen
                   );
           }
   151-153 AUE_NULL        RESERVED
   ; 154 is initialised by the NLM code, if present.
   154     AUE_NULL        NOSTD {
                   int nlm_syscall(
                       int debug_level,
                       int grace_period,
                       int addr_count,
                       _In_reads_(addr_count) char **addrs
                   );
           }
   ; 155 is initialized by the NFS code, if present.
   155     AUE_NFS_SVC     NOSTD {
                   int nfssvc(
                       int flag,
                       _In_ void *argp
                   );
           }
   156     AUE_GETDIRENTRIES       COMPAT|CAPENABLED {
                   int getdirentries(
                       int fd,
                       _Out_writes_bytes_(count) char *buf,
                      u_int count,
                      _Out_ long *basep
                  );
          }
  157     AUE_STATFS      COMPAT4 {
                  int statfs(
                      _In_z_ const char *path,
                      _Out_ _Contains_long_ struct ostatfs *buf
                  );
          }
  158     AUE_FSTATFS     COMPAT4|CAPENABLED {
                  int fstatfs(
                      int fd,
                      _Out_ _Contains_long_ struct ostatfs *buf
                  );
          }
  159     AUE_NULL        RESERVED
  160     AUE_LGETFH      STD {
                  int lgetfh(
                      _In_z_ const char *fname,
                      _Out_ struct fhandle *fhp
                  );
          }
  161     AUE_NFS_GETFH   STD {
                  int getfh(
                      _In_z_ const char *fname,
                      _Out_ struct fhandle *fhp
                  );
          }
  162     AUE_SYSCTL      COMPAT4|CAPENABLED {
                  int getdomainname(
                      _Out_writes_z_(len) char *domainname,
                      int len
                  );
          }
  163     AUE_SYSCTL      COMPAT4 {
                  int setdomainname(
                      _In_reads_z_(len) char *domainname,
                      int len
                  );
          }
  164     AUE_NULL        COMPAT4 {
                  int uname(
                      _Out_ struct utsname *name
                  );
          }
  165     AUE_SYSARCH     STD|CAPENABLED {
                  int sysarch(
                      int op,
                      _In_z_ char *parms
                  );
          }
  166     AUE_RTPRIO      STD|CAPENABLED {
                  int rtprio(
                      int function,
                      pid_t pid,
                      _Inout_ struct rtprio *rtp
                  );
          }
  167-168 AUE_NULL        RESERVED
  169     AUE_SEMSYS      NOSTD {
                  int semsys(
                      int which,
                      int a2,
                      int a3,
                      int a4,
                      int a5
                  );
          }
  ; XXX should be { int semsys(int which, ...); }
  170     AUE_MSGSYS      NOSTD {
                  int msgsys(
                      int which,
                      int a2,
                      int a3,
                      int a4,
                      int a5,
                      int a6
                  );
          }
  ; XXX should be { int msgsys(int which, ...); }
  171     AUE_SHMSYS      NOSTD {
                  int shmsys(
                      int which,
                      int a2,
                      int a3,
                      int a4
                  );
          }
  ; XXX should be { int shmsys(int which, ...); }
  172     AUE_NULL        RESERVED
  173     AUE_PREAD       COMPAT6|CAPENABLED {
                  ssize_t pread(
                      int fd,
                      _Out_writes_bytes_(nbyte) void *buf,
                      size_t nbyte,
                      int pad,
                      off_t offset
                  );
          }
  174     AUE_PWRITE      COMPAT6|CAPENABLED {
                  ssize_t pwrite(
                      int fd,
                      _In_reads_bytes_(nbyte) const void *buf,
                      size_t nbyte,
                      int pad,
                      off_t offset
                  );
          }
  175     AUE_SETFIB      STD {
                  int setfib(
                      int fibnum
                  );
          }
  176     AUE_NTP_ADJTIME STD {
                  int ntp_adjtime(
                      _Inout_ _Contains_long_ struct timex *tp
                  );
          }
  177-180 AUE_NULL        RESERVED
  181     AUE_SETGID      STD|CAPENABLED {
                  int setgid(
                      gid_t gid
                  );
          }
  182     AUE_SETEGID     STD|CAPENABLED {
                  int setegid(
                      gid_t egid
                  );
          }
  183     AUE_SETEUID     STD|CAPENABLED {
                  int seteuid(
                      uid_t euid
                  );
          }
  184     AUE_NULL        OBSOL   lfs_bmapv
  185     AUE_NULL        OBSOL   lfs_markv
  186     AUE_NULL        OBSOL   lfs_segclean
  187     AUE_NULL        OBSOL   lfs_segwait
  188     AUE_STAT        COMPAT11 {
                  int stat(
                      _In_z_ const char *path,
                      _Out_ _Contains_timet_ struct freebsd11_stat *ub
                  );
          }
  189     AUE_FSTAT       COMPAT11|CAPENABLED {
                  int fstat(
                      int fd,
                      _Out_ _Contains_timet_ struct freebsd11_stat *sb
                  );
          }
  190     AUE_LSTAT       COMPAT11 {
                  int lstat(
                      _In_z_ const char *path,
                      _Out_ _Contains_timet_ struct freebsd11_stat *ub
                  );
          }
  191     AUE_PATHCONF    STD {
                  int pathconf(
                      _In_z_ const char *path,
                      int name
                  );
          }
  192     AUE_FPATHCONF   STD|CAPENABLED {
                  int fpathconf(
                      int fd,
                      int name
                  );
          }
  193     AUE_NULL        RESERVED
  194     AUE_GETRLIMIT   STD|CAPENABLED {
                  int getrlimit(
                      u_int which,
                      _Out_ struct rlimit *rlp
                  );
          }
  195     AUE_SETRLIMIT   STD|CAPENABLED {
                  int setrlimit(
                      u_int which,
                      _In_ struct rlimit *rlp
                  );
          }
  196     AUE_GETDIRENTRIES       COMPAT11|CAPENABLED {
                  int getdirentries(
                      int fd,
                      _Out_writes_bytes_(count) char *buf,
                      u_int count,
                      _Out_ long *basep
                  );
          }
  197     AUE_MMAP        COMPAT6|CAPENABLED {
                  void *mmap(
                      _In_ void *addr,
                      size_t len,
                      int prot,
                      int flags,
                      int fd,
                      int pad,
                      off_t pos
                  );
          }
  198     AUE_NULL        SYSMUX {
                  int __syscall(
                      int64_t number,
                      ...
                  );
          }
  199     AUE_LSEEK       COMPAT6|CAPENABLED {
                  off_t lseek(
                      int fd,
                      int pad,
                      off_t offset,
                      int whence
                  );
          }
  200     AUE_TRUNCATE    COMPAT6 {
                  int truncate(
                      _In_z_ const char *path,
                      int pad,
                      off_t length
                  );
          }
  201     AUE_FTRUNCATE   COMPAT6|CAPENABLED {
                  int ftruncate(
                      int fd,
                      int pad,
                      off_t length
                  );
          }
  202     AUE_SYSCTL      STD|CAPENABLED {
                  int __sysctl(
                      _In_reads_(namelen) int *name,
                      u_int namelen,
                      _Out_writes_bytes_opt_(*oldlenp) void *old,
                      _Inout_opt_ size_t *oldlenp,
                      _In_reads_bytes_opt_(newlen) const void *new,
                      size_t newlen
                  );
          }
  203     AUE_MLOCK       STD|CAPENABLED {
                  int mlock(
                      _In_ const void *addr,
                      size_t len
                  );
          }
  204     AUE_MUNLOCK     STD|CAPENABLED {
                  int munlock(
                      _In_ const void *addr,
                      size_t len
                  );
          }
  205     AUE_UNDELETE    STD {
                  int undelete(
                      _In_z_ const char *path
                  );
          }
  206     AUE_FUTIMES     STD|CAPENABLED {
                  int futimes(
                      int fd,
                      _In_reads_(2) _Contains_long_timet_ const struct timeval *tptr
                  );
          }
  207     AUE_GETPGID     STD|CAPENABLED {
                  int getpgid(
                      pid_t pid
                  );
          }
  208     AUE_NULL        RESERVED
  209     AUE_POLL        STD|CAPENABLED {
                  int poll(
                      _Inout_updates_(nfds) struct pollfd *fds,
                      u_int nfds,
                      int timeout
                  );
          }
  ;
  ; The following are reserved for loadable syscalls
  ;
  210     AUE_NULL        NODEF|NOTSTATIC lkmnosys lkmnosys nosys_args int
  211     AUE_NULL        NODEF|NOTSTATIC lkmnosys lkmnosys nosys_args int
  212     AUE_NULL        NODEF|NOTSTATIC lkmnosys lkmnosys nosys_args int
  213     AUE_NULL        NODEF|NOTSTATIC lkmnosys lkmnosys nosys_args int
  214     AUE_NULL        NODEF|NOTSTATIC lkmnosys lkmnosys nosys_args int
  215     AUE_NULL        NODEF|NOTSTATIC lkmnosys lkmnosys nosys_args int
  216     AUE_NULL        NODEF|NOTSTATIC lkmnosys lkmnosys nosys_args int
  217     AUE_NULL        NODEF|NOTSTATIC lkmnosys lkmnosys nosys_args int
  218     AUE_NULL        NODEF|NOTSTATIC lkmnosys lkmnosys nosys_args int
  219     AUE_NULL        NODEF|NOTSTATIC lkmnosys lkmnosys nosys_args int
  
  220     AUE_SEMCTL      COMPAT7|NOSTD {
                  int __semctl(
                      int semid,
                      int semnum,
                      int cmd,
                      _Contains_ptr_ union semun_old *arg
                  );
          }
  221     AUE_SEMGET      NOSTD {
                  int semget(
                      key_t key,
                      int nsems,
                      int semflg
                  );
          }
  222     AUE_SEMOP       NOSTD {
                  int semop(
                      int semid,
                      _In_reads_(nsops) struct sembuf *sops,
                      size_t nsops
                  );
          }
  223     AUE_NULL        OBSOL   semconfig
  224     AUE_MSGCTL      COMPAT7|NOSTD {
                  int msgctl(
                      int msqid,
                      int cmd,
                      _Contains_long_ptr_timet_ struct msqid_ds_old *buf
                  );
          }
  225     AUE_MSGGET      NOSTD {
                  int msgget(
                      key_t key,
                      int msgflg
                  );
          }
  226     AUE_MSGSND      NOSTD {
                  int msgsnd(
                      int msqid,
                      _In_reads_bytes_(msgsz) _Contains_long_ const void *msgp,
                      size_t msgsz,
                      int msgflg
                  );
          }
  227     AUE_MSGRCV      NOSTD {
                  ssize_t msgrcv(
                      int msqid,
                      _Out_writes_bytes_(msgsz) _Contains_long_ void *msgp,
                      size_t msgsz,
                      long msgtyp,
                      int msgflg
                  );
          }
  228     AUE_SHMAT       NOSTD {
                  void *shmat(
                      int shmid,
                      _In_ const void *shmaddr,
                      int shmflg
                  );
          }
  229     AUE_SHMCTL      COMPAT7|NOSTD {
                  int shmctl(
                      int shmid,
                      int cmd,
                      _Inout_opt_ _Contains_long_ struct shmid_ds_old *buf
                  );
          }
  230     AUE_SHMDT       NOSTD {
                  int shmdt(
                      _In_ const void *shmaddr
                  );
          }
  231     AUE_SHMGET      NOSTD {
                  int shmget(
                      key_t key,
                      size_t size,
                      int shmflg
                  );
          }
  232     AUE_NULL        STD|CAPENABLED {
                  int clock_gettime(
                      clockid_t clock_id,
                      _Out_ _Contains_long_timet_ struct timespec *tp
                  );
          }
  233     AUE_CLOCK_SETTIME       STD {
                  int clock_settime(
                      clockid_t clock_id,
                      _In_ _Contains_long_timet_ const struct timespec *tp
                  );
          }
  234     AUE_NULL        STD|CAPENABLED {
                  int clock_getres(
                      clockid_t clock_id,
                      _Out_ _Contains_long_timet_ struct timespec *tp
                  );
          }
  235     AUE_NULL        STD|CAPENABLED {
                  int ktimer_create(
                      clockid_t clock_id,
                      _In_ _Contains_long_ptr_ struct sigevent *evp,
                      _Out_ int *timerid
                  );
          }
  236     AUE_NULL        STD|CAPENABLED {
                  int ktimer_delete(
                      int timerid
                  );
          }
  237     AUE_NULL        STD|CAPENABLED {
                  int ktimer_settime(
                      int timerid,
                      int flags,
                      _In_ _Contains_long_timet_ const struct itimerspec *value,
                      _Out_opt_ _Contains_long_timet_ struct itimerspec *ovalue
                  );
          }
  238     AUE_NULL        STD|CAPENABLED {
                  int ktimer_gettime(
                      int timerid,
                      _Out_ _Contains_long_timet_ struct itimerspec *value
                  );
          }
  239     AUE_NULL        STD|CAPENABLED {
                  int ktimer_getoverrun(
                      int timerid
                  );
          }
  240     AUE_NULL        STD|CAPENABLED {
                  int nanosleep(
                      _In_ _Contains_long_timet_ const struct timespec *rqtp,
                      _Out_opt_ _Contains_long_timet_ struct timespec *rmtp
                  );
          }
  241     AUE_NULL        STD {
                  int ffclock_getcounter(
                      _Out_ ffcounter *ffcount
                  );
          }
  242     AUE_NULL        STD {
                  int ffclock_setestimate(
                      _In_ _Contains_timet_ struct ffclock_estimate *cest
                  );
          }
  243     AUE_NULL        STD {
                  int ffclock_getestimate(
                      _Out_ _Contains_timet_ struct ffclock_estimate *cest
                  );
          }
  244     AUE_NULL        STD {
                  int clock_nanosleep(
                      clockid_t clock_id,
                      int flags,
                      _In_ _Contains_long_timet_ const struct timespec *rqtp,
                      _Out_opt_ _Contains_long_timet_ struct timespec *rmtp
                  );
          }
  245-246 AUE_NULL        RESERVED
  247     AUE_NULL        STD {
                  int clock_getcpuclockid2(
                      id_t id,
                      int which,
                      _Out_ clockid_t *clock_id
                  );
          }
  248     AUE_NULL        STD|CAPENABLED {
                  int ntp_gettime(
                      _Out_ _Contains_long_timet_ struct ntptimeval *ntvp
                  );
          }
  249     AUE_NULL        RESERVED
  250     AUE_MINHERIT    STD|CAPENABLED {
                  int minherit(
                      _In_ void *addr,
                      size_t len,
                      int inherit
                  );
          }
  251     AUE_RFORK       STD {
                  int rfork(
                      int flags
                  );
          }
  252     AUE_POLL        OBSOL   openbsd_poll
  253     AUE_ISSETUGID   STD|CAPENABLED {
                  int issetugid(void);
          }
  254     AUE_LCHOWN      STD {
                  int lchown(
                      _In_z_ const char *path,
                      int uid,
                      int gid
                  );
          }
  255     AUE_AIO_READ    STD|CAPENABLED {
                  int aio_read(
                      _Inout_ _Contains_long_ptr_ struct aiocb *aiocbp
                  );
          }
  256     AUE_AIO_WRITE   STD|CAPENABLED {
                  int aio_write(
                      _Inout_ _Contains_long_ptr_ struct aiocb *aiocbp
                  );
          }
  257     AUE_LIO_LISTIO  STD|CAPENABLED {
                  int lio_listio(
                      int mode,
                      _Inout_updates_(nent) _Contains_long_ptr_ struct aiocb * const *acb_list,
                      int nent,
                      _In_opt_ _Contains_long_ptr_ struct sigevent *sig
                  );
          }
  258-271 AUE_NULL        RESERVED
  272     AUE_O_GETDENTS  COMPAT11|CAPENABLED {
                  int getdents(
                      int fd,
                      _Out_writes_bytes_(count) char *buf,
                      size_t count
                  );
          }
  273     AUE_NULL        RESERVED
  274     AUE_LCHMOD      STD {
                  int lchmod(
                      _In_z_ const char *path,
                      mode_t mode
                  );
          }
  275     AUE_NULL        OBSOL   netbsd_lchown
  276     AUE_LUTIMES     STD {
                  int lutimes(
                      _In_z_ const char *path,
                      _In_ _Contains_long_timet_ const struct timeval *tptr
                  );
          }
  277     AUE_NULL        OBSOL   netbsd_msync
  278     AUE_STAT        COMPAT11 {
                  int nstat(
                      _In_z_ const char *path,
                      _Out_ _Contains_long_timet_ struct nstat *ub
                  );
          }
  279     AUE_FSTAT       COMPAT11 {
                  int nfstat(
                      int fd,
                      _Out_ _Contains_long_timet_ struct nstat *sb
                  );
          }
  280     AUE_LSTAT       COMPAT11 {
                  int nlstat(
                      _In_z_ const char *path,
                      _Out_ _Contains_long_timet_ struct nstat *ub
                  );
          }
  281-288 AUE_NULL        RESERVED
  289     AUE_PREADV      STD|CAPENABLED {
                  ssize_t preadv(
                      int fd,
                      _In_reads_(iovcnt) _Contains_long_ptr_ struct iovec *iovp,
                      u_int iovcnt,
                      off_t offset
                  );
          }
  290     AUE_PWRITEV     STD|CAPENABLED {
                  ssize_t pwritev(
                      int fd,
                      _In_reads_(iovcnt) _Contains_long_ptr_ struct iovec *iovp,
                      u_int iovcnt,
                      off_t offset
                  );
          }
  291-296 AUE_NULL        RESERVED
  297     AUE_FHSTATFS    COMPAT4 {
                  int fhstatfs(
                      _In_ const struct fhandle *u_fhp,
                      _Out_ _Contains_long_ struct ostatfs *buf
                  );
          }
  298     AUE_FHOPEN      STD {
                  int fhopen(
                      _In_ const struct fhandle *u_fhp,
                      int flags
                  );
          }
  299     AUE_FHSTAT      COMPAT11 {
                  int fhstat(
                      _In_ const struct fhandle *u_fhp,
                      _Out_ _Contains_long_timet_ struct freebsd11_stat *sb
                  );
          }
  300     AUE_NULL        STD {
                  int modnext(
                      int modid
                  );
          }
  301     AUE_NULL        STD {
                  int modstat(
                      int modid,
                      _Out_ _Contains_long_ struct module_stat *stat
                  );
          }
  302     AUE_NULL        STD {
                  int modfnext(
                      int modid
                  );
          }
  303     AUE_NULL        STD {
                  int modfind(
                      _In_z_ const char *name
                  );
          }
  304     AUE_MODLOAD     STD {
                  int kldload(
                      _In_z_ const char *file
                  );
          }
  305     AUE_MODUNLOAD   STD {
                  int kldunload(
                      int fileid
                  );
          }
  306     AUE_NULL        STD {
                  int kldfind(
                      _In_z_ const char *file
                  );
          }
  307     AUE_NULL        STD {
                  int kldnext(
                      int fileid
                  );
          }
  308     AUE_NULL        STD {
                  int kldstat(
                      int fileid,
                      _Out_ _Contains_long_ptr_ struct kld_file_stat *stat
                  );
          }
  309     AUE_NULL        STD {
                  int kldfirstmod(
                      int fileid
                  );
          }
  310     AUE_GETSID      STD|CAPENABLED {
                  int getsid(
                      pid_t pid
                  );
          }
  311     AUE_SETRESUID   STD|CAPENABLED {
                  int setresuid(
                      uid_t ruid,
                      uid_t euid,
                      uid_t suid
                  );
          }
  312     AUE_SETRESGID   STD|CAPENABLED {
                  int setresgid(
                      gid_t rgid,
                      gid_t egid,
                      gid_t sgid
                  );
          }
  313     AUE_NULL        OBSOL   signanosleep
  314     AUE_AIO_RETURN  STD|CAPENABLED {
                  ssize_t aio_return(
                      _Inout_ _Contains_long_ptr_ struct aiocb *aiocbp
                  );
          }
  315     AUE_AIO_SUSPEND STD|CAPENABLED {
                  int aio_suspend(
                      _Inout_updates_(nent) _Contains_long_ptr_ struct aiocb * const * aiocbp,
                      int nent,
                      _In_opt_ _Contains_long_timet_ const struct timespec *timeout
                  );
          }
  316     AUE_AIO_CANCEL  STD|CAPENABLED {
                  int aio_cancel(
                      int fd,
                      _In_opt_ _Contains_long_ptr_ struct aiocb *aiocbp
                  );
          }
  317     AUE_AIO_ERROR   STD|CAPENABLED {
                  int aio_error(
                      _In_ _Contains_long_ptr_ struct aiocb *aiocbp
                  );
          }
  318     AUE_AIO_READ    COMPAT6|CAPENABLED {
                  int aio_read(
                      _Inout_ _Contains_long_ptr_ struct oaiocb *aiocbp
                  );
          }
  319     AUE_AIO_WRITE   COMPAT6|CAPENABLED {
                  int aio_write(
                      _Inout_ _Contains_long_ptr_ struct oaiocb *aiocbp
                  );
          }
  320     AUE_LIO_LISTIO  COMPAT6|CAPENABLED {
                  int lio_listio(
                      int mode,
                      _Inout_updates_(nent) _Contains_long_ptr_ struct oaiocb * const *acb_list,
                      int nent,
                      _In_opt_ _Contains_ptr_ struct osigevent *sig
                  );
          }
  321     AUE_NULL        STD|CAPENABLED {
                  int yield(void);
          }
  322     AUE_NULL        OBSOL   thr_sleep
  323     AUE_NULL        OBSOL   thr_wakeup
  324     AUE_MLOCKALL    STD|CAPENABLED {
                  int mlockall(
                      int how
                  );
          }
  325     AUE_MUNLOCKALL  STD|CAPENABLED {
                  int munlockall(void);
          }
  326     AUE_GETCWD      STD {
                  int __getcwd(
                      _Out_writes_z_(buflen) char *buf,
                      size_t buflen
                  );
          }
  327     AUE_NULL        STD|CAPENABLED {
                  int sched_setparam(
                      pid_t pid,
                      _In_ const struct sched_param *param
                  );
          }
  328     AUE_NULL        STD|CAPENABLED {
                  int sched_getparam(
                      pid_t pid,
                      _Out_ struct sched_param *param
                  );
          }
  329     AUE_NULL        STD|CAPENABLED {
                  int sched_setscheduler(
                      pid_t pid,
                      int policy,
                      _In_ const struct sched_param *param
                  );
          }
  330     AUE_NULL        STD|CAPENABLED {
                  int sched_getscheduler(
                      pid_t pid
                  );
          }
  331     AUE_NULL        STD|CAPENABLED {
                  int sched_yield(void);
          }
  332     AUE_NULL        STD|CAPENABLED {
                  int sched_get_priority_max(
                      int policy
                  );
          }
  333     AUE_NULL        STD|CAPENABLED {
                  int sched_get_priority_min(
                      int policy
                  );
          }
  334     AUE_NULL        STD|CAPENABLED {
                  int sched_rr_get_interval(
                      pid_t pid,
                      _Out_ _Contains_long_timet_ struct timespec *interval
                  );
          }
  335     AUE_NULL        STD|CAPENABLED {
                  int utrace(
                      _In_reads_bytes_(len) const void *addr,
                      size_t len
                  );
          }
  336     AUE_SENDFILE    COMPAT4|CAPENABLED {
                  int sendfile(
                      int fd,
                      int s,
                      off_t offset,
                      size_t nbytes,
                      _In_opt_ _Contains_ptr_ struct sf_hdtr *hdtr,
                      _Out_opt_ off_t *sbytes,
                      int flags
                  );
          }
  337     AUE_NULL        STD {
                  int kldsym(
                      int fileid,
                      int cmd,
                      _In_ _Contains_long_ptr_ void *data
                  );
          }
  338     AUE_JAIL        STD {
                  int jail(
                      _In_ _Contains_ptr_ struct jail *jail
                  );
          }
  339     AUE_NULL        NOSTD|NOTSTATIC {
                  int nnpfs_syscall(
                      int operation,
                      char *a_pathP,
                      int a_opcode,
                      void *a_paramsP,
                      int a_followSymlinks
                  );
          }
  340     AUE_SIGPROCMASK STD|CAPENABLED {
                  int sigprocmask(
                      int how,
                      _In_opt_ const sigset_t *set,
                      _Out_opt_ sigset_t *oset
                  );
          }
  341     AUE_SIGSUSPEND  STD|CAPENABLED {
                  int sigsuspend(
                      _In_ const sigset_t *sigmask
                  );
          }
  342     AUE_SIGACTION   COMPAT4|CAPENABLED {
                  int sigaction(
                      int sig,
                      _In_opt_ _Contains_ptr_ const struct sigaction *act,
                      _Out_opt_ _Contains_ptr_ struct sigaction *oact
                  );
          }
  343     AUE_SIGPENDING  STD|CAPENABLED {
                  int sigpending(
                      _In_ sigset_t *set
                  );
          }
  344     AUE_SIGRETURN   COMPAT4|CAPENABLED {
                  int sigreturn(
                      _In_ _Contains_long_ptr_ const struct freebsd4_ucontext *sigcntxp
                  );
          }
  345     AUE_SIGWAIT     STD|CAPENABLED {
                  int sigtimedwait(
                      _In_ const sigset_t *set,
                      _Out_opt_ _Contains_long_ptr_ struct siginfo *info,
                      _In_opt_ _Contains_long_timet_ const struct timespec *timeout
                  );
          }
  346     AUE_NULL        STD|CAPENABLED {
                  int sigwaitinfo(
                      _In_ const sigset_t *set,
                      _Out_opt_ _Contains_long_ptr_ struct siginfo *info
                  );
          }
  347     AUE_ACL_GET_FILE        STD {
                  int __acl_get_file(
                      _In_z_ const char *path,
                      acl_type_t type,
                      _Out_ struct acl *aclp
                  );
          }
  348     AUE_ACL_SET_FILE        STD {
                  int __acl_set_file(
                      _In_z_ const char *path,
                      acl_type_t type,
                      _In_ struct acl *aclp
                  );
          }
  349     AUE_ACL_GET_FD  STD|CAPENABLED {
                  int __acl_get_fd(
                      int filedes,
                      acl_type_t type,
                      _Out_ struct acl *aclp
                  );
          }
  350     AUE_ACL_SET_FD  STD|CAPENABLED {
                  int __acl_set_fd(
                      int filedes,
                      acl_type_t type,
                      _In_ struct acl *aclp
                  );
          }
  351     AUE_ACL_DELETE_FILE     STD {
                  int __acl_delete_file(
                      _In_z_ const char *path,
                      acl_type_t type
                  );
          }
  352     AUE_ACL_DELETE_FD       STD|CAPENABLED {
                  int __acl_delete_fd(
                      int filedes,
                      acl_type_t type
                  );
          }
  353     AUE_ACL_CHECK_FILE      STD {
                  int __acl_aclcheck_file(
                      _In_z_ const char *path,
                      acl_type_t type,
                      _In_ struct acl *aclp
                  );
          }
  354     AUE_ACL_CHECK_FD        STD|CAPENABLED {
                  int __acl_aclcheck_fd(
                      int filedes,
                      acl_type_t type,
                      _In_ struct acl *aclp
                  );
          }
  355     AUE_EXTATTRCTL  STD {
                  int extattrctl(
                      _In_z_ const char *path,
                      int cmd,
                      _In_z_opt_ const char *filename,
                      int attrnamespace,
                      _In_z_ const char *attrname
                  );
          }
  356     AUE_EXTATTR_SET_FILE    STD {
                  ssize_t extattr_set_file(
                      _In_z_ const char *path,
                      int attrnamespace,
                      _In_z_ const char *attrname,
                      _In_reads_bytes_(nbytes) void *data,
                      size_t nbytes
                  );
          }
  357     AUE_EXTATTR_GET_FILE    STD {
                  ssize_t extattr_get_file(
                      _In_z_ const char *path,
                      int attrnamespace,
                      _In_z_ const char *attrname,
                      _Out_writes_bytes_(nbytes) void *data,
                      size_t nbytes
                  );
          }
  358     AUE_EXTATTR_DELETE_FILE STD {
                  int extattr_delete_file(
                      _In_z_ const char *path,
                      int attrnamespace,
                      _In_z_ const char *attrname
                  );
          }
  359     AUE_AIO_WAITCOMPLETE    STD|CAPENABLED {
                  ssize_t aio_waitcomplete(
                      _Outptr_result_maybenull_ struct aiocb **aiocbp,
                      _In_opt_ _Contains_long_timet_ struct timespec *timeout
                  );
          }
  360     AUE_GETRESUID   STD|CAPENABLED {
                  int getresuid(
                      _Out_opt_ uid_t *ruid,
                      _Out_opt_ uid_t *euid,
                      _Out_opt_ uid_t *suid
                  );
          }
  361     AUE_GETRESGID   STD|CAPENABLED {
                  int getresgid(
                      _Out_opt_ gid_t *rgid,
                      _Out_opt_ gid_t *egid,
                      _Out_opt_ gid_t *sgid
                  );
          }
  362     AUE_KQUEUE      STD|CAPENABLED {
                  int kqueue(void);
          }
  363     AUE_KEVENT      COMPAT11|CAPENABLED {
                  int kevent(
                      int fd,
                      _In_reads_opt_(nchanges) _Contains_ptr_ const struct freebsd11_kevent *changelist,
                      int nchanges,
                      _Out_writes_opt_(nevents) _Contains_ptr_ struct freebsd11_kevent *eventlist,
                      int nevents,
                      _In_opt_ _Contains_long_timet_ const struct timespec *timeout
                  );
          }
  364     AUE_NULL        OBSOL   __cap_get_proc
  365     AUE_NULL        OBSOL   __cap_set_proc
  366     AUE_NULL        OBSOL   __cap_get_fd
  367     AUE_NULL        OBSOL   __cap_get_file
  368     AUE_NULL        OBSOL   __cap_set_fd
  369     AUE_NULL        OBSOL   __cap_set_file
  370     AUE_NULL        RESERVED
  371     AUE_EXTATTR_SET_FD      STD|CAPENABLED {
                  ssize_t extattr_set_fd(
                      int fd,
                      int attrnamespace,
                      _In_z_ const char *attrname,
                      _In_reads_bytes_(nbytes) void *data,
                      size_t nbytes
                  );
          }
  372     AUE_EXTATTR_GET_FD      STD|CAPENABLED {
                  ssize_t extattr_get_fd(
                      int fd,
                      int attrnamespace,
                      _In_z_ const char *attrname,
                      _Out_writes_bytes_(nbytes) void *data,
                      size_t nbytes
                  );
          }
  373     AUE_EXTATTR_DELETE_FD   STD|CAPENABLED {
                  int extattr_delete_fd(
                      int fd,
                      int attrnamespace,
                      _In_z_ const char *attrname
                  );
          }
  374     AUE_SETUGID     STD {
                  int __setugid(
                      int flag
                  );
          }
  375     AUE_NULL        OBSOL   nfsclnt
  376     AUE_EACCESS     STD {
                  int eaccess(
                      _In_z_ const char *path,
                      int amode
                  );
          }
  377     AUE_NULL        NOSTD|NOTSTATIC {
                  int afs3_syscall(
                      long syscall,
                      long parm1,
                      long parm2,
                      long parm3,
                      long parm4,
                      long parm5,
                      long parm6
                  );
          }
  378     AUE_NMOUNT      STD {
                  int nmount(
                      _In_reads_(iovcnt) _Contains_long_ptr_ struct iovec *iovp,
                      unsigned int iovcnt,
                      int flags
                  );
          }
  379     AUE_NULL        OBSOL   kse_exit
  380     AUE_NULL        OBSOL   kse_wakeup
  381     AUE_NULL        OBSOL   kse_create
  382     AUE_NULL        OBSOL   kse_thr_interrupt
  383     AUE_NULL        OBSOL   kse_release
  384     AUE_NULL        STD|CAPENABLED {
                  int __mac_get_proc(
                      _In_ _Contains_long_ptr_ struct mac *mac_p
                  );
          }
  385     AUE_NULL        STD|CAPENABLED {
                  int __mac_set_proc(
                      _In_ _Contains_long_ptr_ struct mac *mac_p
                  );
          }
  386     AUE_NULL        STD|CAPENABLED {
                  int __mac_get_fd(
                      int fd,
                      _In_ _Contains_long_ptr_ struct mac *mac_p
                  );
          }
  387     AUE_NULL        STD {
                  int __mac_get_file(
                      _In_z_ const char *path_p,
                      _In_ _Contains_long_ptr_ struct mac *mac_p
                  );
          }
  388     AUE_NULL        STD|CAPENABLED {
                  int __mac_set_fd(
                      int fd,
                      _In_ _Contains_long_ptr_ struct mac *mac_p
                  );
          }
  389     AUE_NULL        STD {
                  int __mac_set_file(
                      _In_z_ const char *path_p,
                      _In_ _Contains_long_ptr_ struct mac *mac_p
                  );
          }
  390     AUE_NULL        STD {
                  int kenv(
                      int what,
                      _In_z_opt_ const char *name,
                      _Inout_updates_opt_(len) char *value,
                      int len
                  );
          }
  391     AUE_LCHFLAGS    STD {
                  int lchflags(
                      _In_z_ const char *path,
                      u_long flags
                  );
          }
  392     AUE_NULL        STD|CAPENABLED {
                  int uuidgen(
                      _Out_writes_(count) struct uuid *store,
                      int count
                  );
          }
  393     AUE_SENDFILE    STD|CAPENABLED {
                  int sendfile(
                      int fd,
                      int s,
                      off_t offset,
                      size_t nbytes,
                      _In_opt_ _Contains_ptr_ struct sf_hdtr *hdtr,
                      _Out_opt_ off_t *sbytes,
                      int flags
                  );
          }
  394     AUE_NULL        STD {
                  int mac_syscall(
                      _In_z_ const char *policy,
                      int call,
                      _In_opt_ void *arg
                  );
          }
  395     AUE_GETFSSTAT   COMPAT11 {
                  int getfsstat(
                      _Out_writes_bytes_opt_(bufsize) struct freebsd11_statfs *buf,
                      long bufsize,
                      int mode
                  );
          }
  396     AUE_STATFS      COMPAT11 {
                  int statfs(
                      _In_z_ const char *path,
                      _Out_ struct freebsd11_statfs *buf
                  );
          }
  397     AUE_FSTATFS     COMPAT11|CAPENABLED {
                  int fstatfs(
                      int fd,
                      _Out_ struct freebsd11_statfs *buf
                  );
          }
  398     AUE_FHSTATFS    COMPAT11 {
                  int fhstatfs(
                      _In_ const struct fhandle *u_fhp,
                      _Out_ struct freebsd11_statfs *buf
                  );
          }
  399     AUE_NULL        RESERVED
  400     AUE_SEMCLOSE    NOSTD {
                  int ksem_close(
                      semid_t id
                  );
          }
  401     AUE_SEMPOST     NOSTD {
                  int ksem_post(
                      semid_t id
                  );
          }
  402     AUE_SEMWAIT     NOSTD {
                  int ksem_wait(
                      semid_t id
                  );
          }
  403     AUE_SEMTRYWAIT  NOSTD {
                  int ksem_trywait(
                      semid_t id
                  );
          }
  404     AUE_SEMINIT     NOSTD {
                  int ksem_init(
                      _Out_ semid_t *idp,
                      unsigned int value
                  );
          }
  405     AUE_SEMOPEN     NOSTD {
                  int ksem_open(
                      _Out_ semid_t *idp,
                      _In_z_ const char *name,
                      int oflag,
                      mode_t mode,
                      unsigned int value
                  );
          }
  406     AUE_SEMUNLINK   NOSTD {
                  int ksem_unlink(
                      _In_z_ const char *name
                  );
          }
  407     AUE_SEMGETVALUE NOSTD {
                  int ksem_getvalue(
                      semid_t id,
                      _Out_ int *val
                  );
          }
  408     AUE_SEMDESTROY  NOSTD {
                  int ksem_destroy(
                      semid_t id
                  );
          }
  409     AUE_NULL        STD {
                  int __mac_get_pid(
                      pid_t pid,
                      _In_ _Contains_long_ptr_ struct mac *mac_p
                  );
          }
  410     AUE_NULL        STD {
                  int __mac_get_link(
                      _In_z_ const char *path_p,
                      _In_ _Contains_long_ptr_ struct mac *mac_p
                  );
          }
  411     AUE_NULL        STD {
                  int __mac_set_link(
                      _In_z_ const char *path_p,
                      _In_ _Contains_long_ptr_ struct mac *mac_p
                  );
          }
  412     AUE_EXTATTR_SET_LINK    STD {
                  ssize_t extattr_set_link(
                      _In_z_ const char *path,
                      int attrnamespace,
                      _In_z_ const char *attrname,
                      _In_reads_bytes_(nbytes) void *data,
                      size_t nbytes
                  );
          }
  413     AUE_EXTATTR_GET_LINK    STD {
                  ssize_t extattr_get_link(
                      _In_z_ const char *path,
                      int attrnamespace,
                      _In_z_ const char *attrname,
                      _Out_writes_bytes_(nbytes) void *data,
                      size_t nbytes
                  );
          }
  414     AUE_EXTATTR_DELETE_LINK STD {
                  int extattr_delete_link(
                      _In_z_ const char *path,
                      int attrnamespace,
                      _In_z_ const char *attrname
                  );
          }
  415     AUE_NULL        STD {
                  int __mac_execve(
                      _In_z_ const char *fname,
                      _In_ char **argv,
                      _In_ char **envv,
                      _In_ _Contains_long_ptr_ struct mac *mac_p
                  );
          }
  416     AUE_SIGACTION   STD|CAPENABLED {
                  int sigaction(
                      int sig,
                      _In_opt_ _Contains_ptr_ const struct sigaction *act,
                      _Out_opt_ _Contains_ptr_ struct sigaction *oact
                  );
          }
  417     AUE_SIGRETURN   STD|CAPENABLED {
                  int sigreturn(
                      _In_ _Contains_long_ptr_ const struct __ucontext *sigcntxp
                  );
          }
  418-420 AUE_NULL        RESERVED
  421     AUE_NULL        STD|CAPENABLED {
                  int getcontext(
                      _Out_ _Contains_long_ptr_ struct __ucontext *ucp
                  );
          }
  422     AUE_NULL        STD|CAPENABLED {
                  int setcontext(
                      _In_ _Contains_long_ptr_ const struct __ucontext *ucp
                  );
          }
  423     AUE_NULL        STD {
                  int swapcontext(
                      _Out_ _Contains_long_ptr_ struct __ucontext *oucp,
                      _In_ _Contains_long_ptr_ const struct __ucontext *ucp
                  );
          }
  424     AUE_SWAPOFF     COMPAT13 {
                  int swapoff(
                      _In_z_ const char *name
                  );
          }
  425     AUE_ACL_GET_LINK        STD {
                  int __acl_get_link(
                      _In_z_ const char *path,
                      acl_type_t type,
                      _Out_ struct acl *aclp
                  );
          }
  426     AUE_ACL_SET_LINK        STD {
                  int __acl_set_link(
                      _In_z_ const char *path,
                      acl_type_t type,
                      _In_ struct acl *aclp
                  );
          }
  427     AUE_ACL_DELETE_LINK     STD {
                  int __acl_delete_link(
                      _In_z_ const char *path,
                      acl_type_t type
                  );
          }
  428     AUE_ACL_CHECK_LINK      STD {
                  int __acl_aclcheck_link(
                      _In_z_ const char *path,
                      acl_type_t type,
                      _In_ struct acl *aclp
                  );
          }
  429     AUE_SIGWAIT     STD|CAPENABLED {
                  int sigwait(
                      _In_ const sigset_t *set,
                      _Out_ int *sig
                  );
          }
  430     AUE_THR_CREATE  STD|CAPENABLED {
                  int thr_create(
                      _In_ _Contains_long_ptr_ ucontext_t *ctx,
                      _Out_ long *id,
                      int flags
                  );
          }
  431     AUE_THR_EXIT    STD|CAPENABLED {
                  void thr_exit(
                      _Out_opt_ long *state
                  );
          }
  432     AUE_NULL        STD|CAPENABLED {
                  int thr_self(
                      _Out_ long *id
                  );
          }
  433     AUE_THR_KILL    STD|CAPENABLED {
                  int thr_kill(
                      long id,
                      int sig
                  );
          }
  
  434     AUE_NULL        COMPAT10 {
                  int _umtx_lock(
                      _Inout_ struct umtx *umtx
                  );
          }
  
  435     AUE_NULL        COMPAT10 {
                  int _umtx_unlock(
                      _Inout_ struct umtx *umtx
                  );
          }
  
  436     AUE_JAIL_ATTACH STD {
                  int jail_attach(
                      int jid
                  );
          }
  437     AUE_EXTATTR_LIST_FD     STD|CAPENABLED {
                  ssize_t extattr_list_fd(
                      int fd,
                      int attrnamespace,
                      _Out_writes_bytes_opt_(nbytes) void *data,
                      size_t nbytes
                  );
          }
  438     AUE_EXTATTR_LIST_FILE   STD {
                  ssize_t extattr_list_file(
                      _In_z_ const char *path,
                      int attrnamespace,
                      _Out_writes_bytes_opt_(nbytes) void *data,
                      size_t nbytes
                  );
          }
  439     AUE_EXTATTR_LIST_LINK   STD {
                  ssize_t extattr_list_link(
                      _In_z_ const char *path,
                      int attrnamespace,
                      _Out_writes_bytes_opt_(nbytes) void *data,
                      size_t nbytes
                  );
          }
  440     AUE_NULL        OBSOL   kse_switchin
  441     AUE_SEMWAIT     NOSTD {
                  int ksem_timedwait(
                      semid_t id,
                      _In_opt_ _Contains_long_timet_ const struct timespec *abstime
                  );
          }
  442     AUE_NULL        STD|CAPENABLED {
                  int thr_suspend(
                      _In_opt_ _Contains_long_timet_ const struct timespec *timeout
                  );
          }
  443     AUE_NULL        STD|CAPENABLED {
                  int thr_wake(
                      long id
                  );
          }
  444     AUE_MODUNLOAD   STD {
                  int kldunloadf(
                      int fileid,
                      int flags
                  );
          }
  445     AUE_AUDIT       STD {
                  int audit(
                      _In_reads_bytes_(length) const void *record,
                      u_int length
                  );
          }
  446     AUE_AUDITON     STD {
                  int auditon(
                      int cmd,
                      _In_opt_ void *data,
                      u_int length
                  );
          }
  447     AUE_GETAUID     STD|CAPENABLED {
                  int getauid(
                      _Out_ uid_t *auid
                  );
          }
  448     AUE_SETAUID     STD|CAPENABLED {
                  int setauid(
                      _In_ uid_t *auid
                  );
          }
  449     AUE_GETAUDIT    STD|CAPENABLED {
                  int getaudit(
                      _Out_ struct auditinfo *auditinfo
                  );
          }
  450     AUE_SETAUDIT    STD|CAPENABLED {
                  int setaudit(
                      _In_ struct auditinfo *auditinfo
                  );
          }
  451     AUE_GETAUDIT_ADDR       STD|CAPENABLED {
                  int getaudit_addr(
                      _Out_writes_bytes_(length) struct auditinfo_addr *auditinfo_addr,
                      u_int length
                  );
          }
  452     AUE_SETAUDIT_ADDR       STD|CAPENABLED {
                  int setaudit_addr(
                      _In_reads_bytes_(length) struct auditinfo_addr *auditinfo_addr,
                      u_int length
                  );
          }
  453     AUE_AUDITCTL    STD {
                  int auditctl(
                      _In_z_ const char *path
                  );
          }
  454     AUE_NULL        STD|CAPENABLED {
                  int _umtx_op(
                      _Inout_ void *obj,
                      int op,
                      u_long val,
                      _In_ void *uaddr1,
                      _In_ void *uaddr2
                  );
          }
  455     AUE_THR_NEW     STD|CAPENABLED {
                  int thr_new(
                      _In_ _Contains_long_ptr_ struct thr_param *param,
                      int param_size
                  );
          }
  456     AUE_NULL        STD|CAPENABLED {
                  int sigqueue(
                      pid_t pid,
                      int signum,
                      _In_ void *value
                  );
          }
  
  457     AUE_MQ_OPEN     NOSTD {
                  int kmq_open(
                      _In_z_ const char *path,
                      int flags,
                      mode_t mode,
                      _In_opt_ _Contains_long_ const struct mq_attr *attr
                  );
          }
  458     AUE_MQ_SETATTR  NOSTD|CAPENABLED {
                  int kmq_setattr(
                      int mqd,
                      _In_opt_ _Contains_long_ const struct mq_attr *attr,
                      _Out_opt_ _Contains_long_ struct mq_attr *oattr
                  );
          }
  459     AUE_MQ_TIMEDRECEIVE     NOSTD|CAPENABLED {
                  int kmq_timedreceive(
                      int mqd,
                      _Out_writes_bytes_(msg_len) char *msg_ptr,
                      size_t msg_len,
                      _Out_opt_ unsigned *msg_prio,
                      _In_opt_ _Contains_long_timet_ const struct timespec *abs_timeout
                  );
          }
  460     AUE_MQ_TIMEDSEND        NOSTD|CAPENABLED {
                  int kmq_timedsend(
                      int mqd,
                      _In_reads_bytes_(msg_len) const char *msg_ptr,
                      size_t msg_len,
                      unsigned msg_prio,
                      _In_opt_ _Contains_long_timet_ const struct timespec *abs_timeout
                  );
          }
  461     AUE_MQ_NOTIFY   NOSTD|CAPENABLED {
                  int kmq_notify(
                      int mqd,
                      _In_opt_ _Contains_long_ptr_ const struct sigevent *sigev
                  );
          }
  462     AUE_MQ_UNLINK   NOSTD {
                  int kmq_unlink(
                      _In_z_ const char *path
                  );
          }
  463     AUE_NULL        STD|CAPENABLED {
                  void abort2(
                      _In_z_ const char *why,
                      int nargs,
                      _In_reads_(nargs) void **args
                  );
          }
  464     AUE_NULL        STD|CAPENABLED {
                  int thr_set_name(
                      long id,
                      _In_z_ const char *name
                  );
          }
  465     AUE_AIO_FSYNC   STD|CAPENABLED {
                  int aio_fsync(
                      int op,
                      _In_ _Contains_long_ptr_ struct aiocb *aiocbp
                  );
          }
  466     AUE_RTPRIO      STD|CAPENABLED {
                  int rtprio_thread(
                      int function,
                      lwpid_t lwpid,
                      _Inout_ struct rtprio *rtp
                  );
          }
  467-470 AUE_NULL        RESERVED
  471     AUE_SCTP_PEELOFF        NOSTD|CAPENABLED {
                  int sctp_peeloff(
                      int sd,
                      uint32_t name
                  );
          }
  472     AUE_SCTP_GENERIC_SENDMSG        NOSTD|CAPENABLED {
                  int sctp_generic_sendmsg(
                      int sd,
                      _In_reads_bytes_(mlen) void *msg,
                      int mlen,
                      _In_reads_bytes_(tolen) const struct sockaddr *to,
                      __socklen_t tolen,
                      _In_opt_ struct sctp_sndrcvinfo *sinfo,
                      int flags
                  );
          }
  473     AUE_SCTP_GENERIC_SENDMSG_IOV    NOSTD|CAPENABLED {
                  int sctp_generic_sendmsg_iov(
                      int sd,
                      _In_reads_(iovlen) _Contains_long_ptr_ struct iovec *iov,
                      int iovlen,
                      _In_reads_bytes_(tolen) const struct sockaddr *to,
                      __socklen_t tolen,
                      _In_opt_ struct sctp_sndrcvinfo *sinfo,
                      int flags
                  );
          }
  474     AUE_SCTP_GENERIC_RECVMSG        NOSTD|CAPENABLED {
                  int sctp_generic_recvmsg(
                      int sd,
                      _In_reads_(iovlen) _Contains_long_ptr_ struct iovec *iov,
                      int iovlen,
                      _Out_writes_bytes_(*fromlenaddr) struct sockaddr *from,
                      _Out_ __socklen_t *fromlenaddr,
                      _In_opt_ struct sctp_sndrcvinfo *sinfo,
                      _Out_opt_ int *msg_flags
                  );
          }
  475     AUE_PREAD       STD|CAPENABLED {
                  ssize_t pread(
                      int fd,
                      _Out_writes_bytes_(nbyte) void *buf,
                      size_t nbyte,
                      off_t offset
                  );
          }
  476     AUE_PWRITE      STD|CAPENABLED {
                  ssize_t pwrite(
                      int fd,
                      _In_reads_bytes_(nbyte) const void *buf,
                      size_t nbyte,
                      off_t offset
                  );
          }
  477     AUE_MMAP        STD|CAPENABLED {
                  void *mmap(
                      _In_ void *addr,
                      size_t len,
                      int prot,
                      int flags,
                      int fd,
                      off_t pos
                  );
          }
  478     AUE_LSEEK       STD|CAPENABLED {
                  off_t lseek(
                      int fd,
                      off_t offset,
                      int whence
                  );
          }
  479     AUE_TRUNCATE    STD {
                  int truncate(
                      _In_z_ const char *path,
                      off_t length
                  );
          }
  480     AUE_FTRUNCATE   STD|CAPENABLED {
                  int ftruncate(
                      int fd,
                      off_t length
                  );
          }
  481     AUE_THR_KILL2   STD {
                  int thr_kill2(
                      pid_t pid,
                      long id,
                      int sig
                  );
          }
  482     AUE_SHMOPEN     COMPAT12|CAPENABLED {
                  int shm_open(
                      _In_z_ const char *path,
                      int flags,
                      mode_t mode
                  );
          }
  483     AUE_SHMUNLINK   STD {
                  int shm_unlink(
                      _In_z_ const char *path
                  );
          }
  484     AUE_NULL        STD {
                  int cpuset(
                      _Out_ cpusetid_t *setid
                  );
          }
  485     AUE_NULL        STD {
                  int cpuset_setid(
                      cpuwhich_t which,
                      id_t id,
                      cpusetid_t setid
                  );
          }
  486     AUE_NULL        STD {
                  int cpuset_getid(
                      cpulevel_t level,
                      cpuwhich_t which,
                      id_t id,
                      _Out_ cpusetid_t *setid
                  );
          }
  487     AUE_NULL        STD|CAPENABLED {
                  int cpuset_getaffinity(
                      cpulevel_t level,
                      cpuwhich_t which,
                      id_t id,
                      size_t cpusetsize,
                      _Out_ cpuset_t *mask
                  );
          }
  488     AUE_NULL        STD|CAPENABLED {
                  int cpuset_setaffinity(
                      cpulevel_t level,
                      cpuwhich_t which,
                      id_t id,
                      size_t cpusetsize,
                      _Out_ const cpuset_t *mask
                  );
          }
  489     AUE_FACCESSAT   STD|CAPENABLED {
                  int faccessat(
                      int fd,
                      _In_z_ const char *path,
                      int amode,
                      int flag
                  );
          }
  490     AUE_FCHMODAT    STD|CAPENABLED {
                  int fchmodat(
                      int fd,
                      _In_z_ const char *path,
                      mode_t mode,
                      int flag
                  );
          }
  491     AUE_FCHOWNAT    STD|CAPENABLED {
                  int fchownat(
                      int fd,
                      _In_z_ const char *path,
                      uid_t uid,
                      gid_t gid,
                      int flag
                  );
          }
  492     AUE_FEXECVE     STD|CAPENABLED {
                  int fexecve(
                      int fd,
                      _In_ char **argv,
                      _In_ char **envv
                  );
          }
  493     AUE_FSTATAT     COMPAT11|CAPENABLED {
                  int fstatat(
                      int fd,
                      _In_z_ const char *path,
                      _Out_ _Contains_long_timet_ struct freebsd11_stat *buf,
                      int flag
                  );
          }
  494     AUE_FUTIMESAT   STD|CAPENABLED {
                  int futimesat(
                      int fd,
                      _In_z_ const char *path,
                      _In_reads_(2) _Contains_long_timet_ const struct timeval *times
                  );
          }
  495     AUE_LINKAT      STD|CAPENABLED {
                  int linkat(
                      int fd1,
                      _In_z_ const char *path1,
                      int fd2,
                      _In_z_ const char *path2,
                      int flag
                  );
          }
  496     AUE_MKDIRAT     STD|CAPENABLED {
                  int mkdirat(
                      int fd,
                      _In_z_ const char *path,
                      mode_t mode
                  );
          }
  497     AUE_MKFIFOAT    STD|CAPENABLED {
                  int mkfifoat(
                      int fd,
                      _In_z_ const char *path,
                      mode_t mode
                  );
          }
  498     AUE_MKNODAT     COMPAT11|CAPENABLED {
                  int mknodat(
                      int fd,
                      _In_z_ const char *path,
                      mode_t mode,
                      uint32_t dev
                  );
          }
  ; XXX: see the comment for open
  499     AUE_OPENAT_RWTC STD|CAPENABLED {
                  int openat(
                      int fd,
                      _In_z_ const char *path,
                      int flag,
                      mode_t mode
                  );
          }
  500     AUE_READLINKAT  STD|CAPENABLED {
                  ssize_t readlinkat(
                      int fd,
                      _In_z_ const char *path,
                      _Out_writes_bytes_(bufsize) char *buf,
                      size_t bufsize
                  );
          }
  501     AUE_RENAMEAT    STD|CAPENABLED {
                  int renameat(
                      int oldfd,
                      _In_z_ const char *old,
                      int newfd,
                      _In_z_ const char *new
                  );
          }
  502     AUE_SYMLINKAT   STD|CAPENABLED {
                  int symlinkat(
                      _In_z_ const char *path1,
                      int fd,
                      _In_z_ const char *path2
                  );
          }
  503     AUE_UNLINKAT    STD|CAPENABLED {
                  int unlinkat(
                      int fd,
                      _In_z_ const char *path,
                      int flag
                  );
          }
  504     AUE_POSIX_OPENPT        STD {
                  int posix_openpt(
                      int flags
                  );
          }
  ; 505 is initialised by the kgssapi code, if present.
  505     AUE_NULL        NOSTD {
                  int gssd_syscall(
                      _In_z_ const char *path
                  );
          }
  506     AUE_JAIL_GET    STD {
                  int jail_get(
                      _In_reads_(iovcnt) _Contains_long_ptr_ struct iovec *iovp,
                      unsigned int iovcnt,
                      int flags
                  );
          }
  507     AUE_JAIL_SET    STD {
                  int jail_set(
                      _In_reads_(iovcnt) _Contains_long_ptr_ struct iovec *iovp,
                      unsigned int iovcnt,
                      int flags
                  );
          }
  508     AUE_JAIL_REMOVE STD {
                  int jail_remove(
                      int jid
                  );
          }
  509     AUE_CLOSEFROM   COMPAT12|CAPENABLED {
                  int closefrom(
                      int lowfd
                  );
          }
  510     AUE_SEMCTL      NOSTD {
                  int __semctl(
                      int semid,
                      int semnum,
                      int cmd,
                      _Inout_ _Contains_ptr_ union semun *arg
                  );
          }
  511     AUE_MSGCTL      NOSTD {
                  int msgctl(
                      int msqid,
                      int cmd,
                      _Inout_opt_ _Contains_long_ptr_ struct msqid_ds *buf
                  );
          }
  512     AUE_SHMCTL      NOSTD {
                  int shmctl(
                      int shmid,
                      int cmd,
                      _Inout_opt_ _Contains_long_ struct shmid_ds *buf
                  );
          }
  513     AUE_LPATHCONF   STD {
                  int lpathconf(
                      _In_z_ const char *path,
                      int name
                  );
          }
  514     AUE_NULL        OBSOL   cap_new
  515     AUE_CAP_RIGHTS_GET      STD|CAPENABLED {
                  int __cap_rights_get(
                      int version,
                      int fd,
                      _Out_ cap_rights_t *rightsp
                  );
          }
  516     AUE_CAP_ENTER   STD|CAPENABLED {
                  int cap_enter(void);
          }
  517     AUE_CAP_GETMODE STD|CAPENABLED {
                  int cap_getmode(
                      _Out_ u_int *modep
                  );
          }
  518     AUE_PDFORK      STD|CAPENABLED {
                  int pdfork(
                      _Out_ int *fdp,
                      int flags
                  );
          }
  519     AUE_PDKILL      STD|CAPENABLED {
                  int pdkill(
                      int fd,
                      int signum
                  );
          }
  520     AUE_PDGETPID    STD|CAPENABLED {
                  int pdgetpid(
                      int fd,
                      _Out_ pid_t *pidp
                  );
          }
  521     AUE_NULL        RESERVED
  522     AUE_SELECT      STD|CAPENABLED {
                  int pselect(
                      int nd,
                      _Inout_opt_ fd_set *in,
                      _Inout_opt_ fd_set *ou,
                      _Inout_opt_ fd_set *ex,
                      _In_opt_ _Contains_long_timet_ const struct timespec *ts,
                      _In_opt_ const sigset_t *sm
                  );
          }
  523     AUE_GETLOGINCLASS       STD|CAPENABLED {
                  int getloginclass(
                      _Out_writes_z_(namelen) char *namebuf,
                      size_t namelen
                  );
          }
  524     AUE_SETLOGINCLASS       STD {
                  int setloginclass(
                      _In_z_ const char *namebuf
                  );
          }
  525     AUE_NULL        STD {
                  int rctl_get_racct(
                      _In_reads_bytes_(inbuflen) const void *inbufp,
                      size_t inbuflen,
                      _Out_writes_bytes_(outbuflen) void *outbufp,
                      size_t outbuflen
                  );
          }
  526     AUE_NULL        STD {
                  int rctl_get_rules(
                      _In_reads_bytes_(inbuflen) const void *inbufp,
                      size_t inbuflen,
                      _Out_writes_bytes_(outbuflen) void *outbufp,
                      size_t outbuflen
                  );
          }
  527     AUE_NULL        STD {
                  int rctl_get_limits(
                      _In_reads_bytes_(inbuflen) const void *inbufp,
                      size_t inbuflen,
                      _Out_writes_bytes_(outbuflen) void *outbufp,
                      size_t outbuflen
                  );
          }
  528     AUE_NULL        STD {
                  int rctl_add_rule(
                      _In_reads_bytes_(inbuflen) const void *inbufp,
                      size_t inbuflen,
                      _Out_writes_bytes_(outbuflen) void *outbufp,
                      size_t outbuflen
                  );
          }
  529     AUE_NULL        STD {
                  int rctl_remove_rule(
                      _In_reads_bytes_(inbuflen) const void *inbufp,
                      size_t inbuflen,
                      _Out_writes_bytes_(outbuflen) void *outbufp,
                      size_t outbuflen
                  );
          }
  530     AUE_POSIX_FALLOCATE     STD|CAPENABLED {
                  int posix_fallocate(
                      int fd,
                      off_t offset,
                      off_t len
                  );
          }
  531     AUE_POSIX_FADVISE       STD|CAPENABLED {
                  int posix_fadvise(
                      int fd,
                      off_t offset,
                      off_t len,
                      int advice
                  );
          }
  532     AUE_WAIT6       STD {
                  int wait6(
                      idtype_t idtype,
                      id_t id,
                      _Out_opt_ int *status,
                      int options,
                      _Out_opt_ _Contains_long_ struct __wrusage *wrusage,
                      _Out_opt_ _Contains_long_ptr_ struct siginfo *info
                  );
          }
  533     AUE_CAP_RIGHTS_LIMIT    STD|CAPENABLED {
                  int cap_rights_limit(
                      int fd,
                      _In_ cap_rights_t *rightsp
                  );
          }
  534     AUE_CAP_IOCTLS_LIMIT    STD|CAPENABLED {
                  int cap_ioctls_limit(
                      int fd,
                      _In_reads_(ncmds) const u_long *cmds,
                      size_t ncmds
                  );
          }
  535     AUE_CAP_IOCTLS_GET      STD|CAPENABLED {
                  ssize_t cap_ioctls_get(
                      int fd,
                      _Out_writes_(maxcmds) u_long *cmds,
                      size_t maxcmds
                  );
          }
  536     AUE_CAP_FCNTLS_LIMIT    STD|CAPENABLED {
                  int cap_fcntls_limit(
                      int fd,
                      uint32_t fcntlrights
                  );
          }
  537     AUE_CAP_FCNTLS_GET      STD|CAPENABLED {
                  int cap_fcntls_get(
                      int fd,
                      _Out_ uint32_t *fcntlrightsp
                  );
          }
  538     AUE_BINDAT      STD|CAPENABLED {
                  int bindat(
                      int fd,
                      int s,
                      _In_reads_bytes_(namelen) const struct sockaddr *name,
                      __socklen_t namelen
                  );
          }
  539     AUE_CONNECTAT   STD|CAPENABLED {
                  int connectat(
                      int fd,
                      int s,
                      _In_reads_bytes_(namelen) const struct sockaddr *name,
                      __socklen_t namelen
                  );
          }
  540     AUE_CHFLAGSAT   STD|CAPENABLED {
                  int chflagsat(
                      int fd,
                      _In_z_ const char *path,
                      u_long flags,
                      int atflag
                  );
          }
  541     AUE_ACCEPT      STD|CAPENABLED {
                  int accept4(
                      int s,
                      _Out_writes_bytes_opt_(*anamelen) struct sockaddr *name,
                      _Inout_opt_ __socklen_t *anamelen,
                      int flags
                  );
          }
  542     AUE_PIPE        STD|CAPENABLED {
                  int pipe2(
                      _Out_writes_(2) int *fildes,
                      int flags
                  );
          }
  543     AUE_AIO_MLOCK   STD {
                  int aio_mlock(
                      _In_ _Contains_long_ptr_ struct aiocb *aiocbp
                  );
          }
  544     AUE_PROCCTL     STD {
                  int procctl(
                      idtype_t idtype,
                      id_t id,
                      int com,
                      _In_opt_ void *data
                  );
          }
  545     AUE_POLL        STD|CAPENABLED {
                  int ppoll(
                      _Inout_updates_(nfds) struct pollfd *fds,
                      u_int nfds,
                      _In_opt_ _Contains_long_timet_ const struct timespec *ts,
                      _In_opt_ const sigset_t *set
                  );
          }
  546     AUE_FUTIMES     STD|CAPENABLED {
                  int futimens(
                      int fd,
                      _In_reads_(2) _Contains_long_timet_ const struct timespec *times
                  );
          }
  547     AUE_FUTIMESAT   STD|CAPENABLED {
                  int utimensat(
                      int fd,
                      _In_z_ const char *path,
                      _In_reads_(2) _Contains_long_timet_ const struct timespec *times,
                      int flag
                  );
          }
  548     AUE_NULL        OBSOL   numa_getaffinity
  549     AUE_NULL        OBSOL   numa_setaffinity
  550     AUE_FSYNC       STD|CAPENABLED {
                  int fdatasync(
                      int fd
                  );
          }
  551     AUE_FSTAT       STD|CAPENABLED {
                  int fstat(
                      int fd,
                      _Out_ _Contains_long_timet_ struct stat *sb
                  );
          }
  552     AUE_FSTATAT     STD|CAPENABLED {
                  int fstatat(
                      int fd,
                      _In_z_ const char *path,
                      _Out_ _Contains_long_timet_ struct stat *buf,
                      int flag
                  );
          }
  553     AUE_FHSTAT      STD {
                  int fhstat(
                      _In_ const struct fhandle *u_fhp,
                      _Out_ _Contains_long_timet_ struct stat *sb
                  );
          }
  554     AUE_GETDIRENTRIES STD|CAPENABLED {
                  ssize_t getdirentries(
                      int fd,
                      _Out_writes_bytes_(count) char *buf,
                      size_t count,
                      _Out_ off_t *basep
                  );
          }
  555     AUE_STATFS      STD {
                  int statfs(
                      _In_z_ const char *path,
                      _Out_ struct statfs *buf
                  );
          }
  556     AUE_FSTATFS     STD|CAPENABLED {
                  int fstatfs(
                      int fd,
                      _Out_ struct statfs *buf
                  );
          }
  557     AUE_GETFSSTAT   STD {
                  int getfsstat(
                      _Out_writes_bytes_opt_(bufsize) struct statfs *buf,
                      long bufsize,
                      int mode
                  );
          }
  558     AUE_FHSTATFS    STD {
                  int fhstatfs(
                      _In_ const struct fhandle *u_fhp,
                      _Out_ struct statfs *buf
                  );
          }
  559     AUE_MKNODAT     STD|CAPENABLED {
                  int mknodat(
                      int fd,
                      _In_z_ const char *path,
                      mode_t mode,
                      dev_t dev
                  );
          }
  560     AUE_KEVENT      STD|CAPENABLED {
                  int kevent(
                      int fd,
                      _In_reads_opt_(nchanges) _Contains_ptr_ const struct kevent *changelist,
                      int nchanges,
                      _Out_writes_opt_(nevents) _Contains_ptr_ struct kevent *eventlist,
                      int nevents,
                      _In_opt_ _Contains_long_timet_ const struct timespec *timeout
                  );
          }
  561     AUE_NULL        STD|CAPENABLED {
                  int cpuset_getdomain(
                      cpulevel_t level,
                      cpuwhich_t which,
                      id_t id,
                      size_t domainsetsize,
                      _Out_writes_bytes_(domainsetsize) domainset_t *mask,
                      _Out_ int *policy
                  );
          }
  562     AUE_NULL        STD|CAPENABLED {
                  int cpuset_setdomain(
                      cpulevel_t level,
                      cpuwhich_t which,
                      id_t id,
                      size_t domainsetsize,
                      _In_ domainset_t *mask,
                      int policy
                  );
          }
  563     AUE_NULL        STD|CAPENABLED {
                  int getrandom(
                      _Out_writes_bytes_(buflen) void *buf,
                      size_t buflen,
                      unsigned int flags
                  );
          }
  564     AUE_NULL        STD {
                  int getfhat(
                      int fd,
                      _In_z_ char *path,
                      _Out_ struct fhandle *fhp,
                      int flags
                  );
          }
  565     AUE_NULL        STD {
                  int fhlink(
                      _In_ struct fhandle *fhp,
                      _In_z_ const char *to
                  );
          }
  566     AUE_NULL        STD {
                  int fhlinkat(
                      _In_ struct fhandle *fhp,
                      int tofd,
                      _In_z_ const char *to,
                  );
          }
  567     AUE_NULL        STD {
                  int fhreadlink(
                      _In_ struct fhandle *fhp,
                      _Out_writes_(bufsize) char *buf,
                      size_t bufsize
                  );
          }
  568     AUE_UNLINKAT    STD|CAPENABLED {
                  int funlinkat(
                      int dfd,
                      _In_z_ const char *path,
                      int fd,
                      int flag
                  );
          }
  569     AUE_NULL        STD|CAPENABLED {
                  ssize_t copy_file_range(
                      int infd,
                      _Inout_opt_ off_t *inoffp,
                      int outfd,
                      _Inout_opt_ off_t *outoffp,
                      size_t len,
                      unsigned int flags
                  );
          }
  570     AUE_SYSCTL      STD|CAPENABLED {
                  int __sysctlbyname(
                      _In_reads_(namelen) const char *name,
                      size_t namelen,
                      _Out_writes_bytes_opt_(*oldlenp) void *old,
                      _Inout_opt_ size_t *oldlenp,
                      _In_reads_bytes_opt_(newlen) void *new,
                      size_t newlen
                  );
          }
  571     AUE_SHMOPEN     STD|CAPENABLED {
                  int shm_open2(
                      _In_z_ const char *path,
                      int flags,
                      mode_t mode,
                      int shmflags,
                      _In_z_ const char *name
                  );
          }
  572     AUE_SHMRENAME   STD {
                  int shm_rename(
                      _In_z_ const char *path_from,
                      _In_z_ const char *path_to,
                      int flags
                  );
          }
  573     AUE_NULL        STD|CAPENABLED {
                  int sigfastblock(
                      int cmd,
                      _Inout_opt_ uint32_t *ptr
                  );
          }
  574     AUE_REALPATHAT  STD {
                  int __realpathat(
                      int fd,
                      _In_z_ const char *path,
                      _Out_writes_z_(size) char *buf,
                      size_t size,
                      int flags
                  );
          }
  575     AUE_CLOSERANGE  STD|CAPENABLED {
                  int close_range(
                      u_int lowfd,
                      u_int highfd,
                      int flags
                  );
          }
  ; 576 is initialised by the krpc code, if present.
  576     AUE_NULL        NOSTD {
                  int rpctls_syscall(
                      int op,
                      _In_z_ const char *path
                  );
          }
  577     AUE_SPECIALFD   STD|CAPENABLED {
                  int __specialfd(
                      int type,
                      _In_reads_bytes_(len) const void *req,
                      size_t len
                  );
          }
  578     AUE_AIO_WRITEV  STD|CAPENABLED {
                  int aio_writev(
                      _Inout_ _Contains_long_ptr_ struct aiocb *aiocbp
                  );
          }
  579     AUE_AIO_READV   STD|CAPENABLED {
                  int aio_readv(
                      _Inout_ _Contains_long_ptr_ struct aiocb *aiocbp
                  );
          }
  580     AUE_FSPACECTL   STD|CAPENABLED {
                  int fspacectl(
                      int fd,
                      int cmd,
                      _In_ const struct spacectl_range *rqsr,
                      int flags,
                      _Out_opt_ struct spacectl_range *rmsr,
                  );
          }
  581     AUE_NULL        STD|CAPENABLED {
                  int sched_getcpu(void);
          }
  
  582     AUE_SWAPOFF     STD {
                  int swapoff(
                      _In_z_ const char *name,
                      u_int flags,
                  );
          }
  
  ; vim: syntax=off

Cache object: 8fc314883093eaf1fcdba04dde203d9f