The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

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

Version: -  FREEBSD  -  FREEBSD11  -  FREEBSD10  -  FREEBSD9  -  FREEBSD92  -  FREEBSD91  -  FREEBSD90  -  FREEBSD8  -  FREEBSD82  -  FREEBSD81  -  FREEBSD80  -  FREEBSD7  -  FREEBSD74  -  FREEBSD73  -  FREEBSD72  -  FREEBSD71  -  FREEBSD70  -  FREEBSD6  -  FREEBSD64  -  FREEBSD63  -  FREEBSD62  -  FREEBSD61  -  FREEBSD60  -  FREEBSD5  -  FREEBSD55  -  FREEBSD54  -  FREEBSD53  -  FREEBSD52  -  FREEBSD51  -  FREEBSD50  -  FREEBSD4  -  FREEBSD3  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    1  $FreeBSD: head/sys/kern/syscalls.master 340302 2018-11-09 21:01:16Z brooks $
    2 ;       from: @(#)syscalls.master       8.2 (Berkeley) 1/13/94
    3 ;
    4 ; System call name/number master file.
    5 ; Processed to created init_sysent.c, syscalls.c and syscall.h.
    6 
    7 ; Columns: number audit type name alt{name,tag,rtyp}/comments
    8 ;       number  system call number, must be in order
    9 ;       audit   the audit event associated with the system call
   10 ;               A value of AUE_NULL means no auditing, but it also means that
   11 ;               there is no audit event for the call at this time. For the
   12 ;               case where the event exists, but we don't want auditing, the
   13 ;               event should be #defined to AUE_NULL in audit_kevents.h.
   14 ;       type    one of STD, OBSOL, UNIMPL, COMPAT, COMPAT4, COMPAT6,
   15 ;               COMPAT7, COMPAT11, NODEF, NOARGS, NOPROTO, NOSTD
   16 ;               The COMPAT* options may be combined with one or more NO*
   17 ;               options separated by '|' with no spaces (e.g. COMPAT|NOARGS)
   18 ;       name    pseudo-prototype of syscall routine
   19 ;               If one of the following alts is different, then all appear:
   20 ;       altname name of system call if different
   21 ;       alttag  name of args struct tag if different from [o]`name'"_args"
   22 ;       altrtyp return type if not int (bogus - syscalls always return int)
   23 ;               for UNIMPL/OBSOL, name continues with comments
   24 
   25 ; types:
   26 ;       STD     always included
   27 ;       COMPAT  included on COMPAT #ifdef
   28 ;       COMPAT4 included on COMPAT_FREEBSD4 #ifdef (FreeBSD 4 compat)
   29 ;       COMPAT6 included on COMPAT_FREEBSD6 #ifdef (FreeBSD 6 compat)
   30 ;       COMPAT7 included on COMPAT_FREEBSD7 #ifdef (FreeBSD 7 compat)
   31 ;       COMPAT10 included on COMPAT_FREEBSD10 #ifdef (FreeBSD 10 compat)
   32 ;       COMPAT11 included on COMPAT_FREEBSD11 #ifdef (FreeBSD 11 compat)
   33 ;       OBSOL   obsolete, not included in system, only specifies name
   34 ;       UNIMPL  not implemented, placeholder only
   35 ;       NOSTD   implemented but as a lkm that can be statically
   36 ;               compiled in; sysent entry will be filled with lkmressys
   37 ;               so the SYSCALL_MODULE macro works
   38 ;       NOARGS  same as STD except do not create structure in sys/sysproto.h
   39 ;       NODEF   same as STD except only have the entry in the syscall table
   40 ;               added.  Meaning - do not create structure or function
   41 ;               prototype in sys/sysproto.h
   42 ;       NOPROTO same as STD except do not create structure or
   43 ;               function prototype in sys/sysproto.h.  Does add a
   44 ;               definition to syscall.h besides adding a sysent.
   45 ;       NOTSTATIC syscall is loadable
   46 
   47 ; annotations:
   48 ;       SAL 2.0 annotations are used to specify how system calls treat
   49 ;       arguments that are passed using pointers. There are three basic
   50 ;       annotations.
   51 ;
   52 ;       _In_    Object pointed to will be read and not modified.
   53 ;       _Out_   Object pointed to will be written and not read.
   54 ;       _Inout_ Object pointed to will be written and read.
   55 ;
   56 ;       These annotations are used alone when the pointer refers to a single
   57 ;       object i.e. scalar types, structs, and pointers, and not NULL. Adding
   58 ;       the _opt_ suffix, e.g. _In_opt_, implies that the pointer may also
   59 ;       refer to NULL.
   60 ;
   61 ;       For pointers to arrays, additional suffixes are added:
   62 ;
   63 ;       _In_z_, _Out_z_, _Inout_z_:
   64 ;           for a NUL terminated array e.g. a string.
   65 ;       _In_reads_z_(n),_Out_writes_z_(n), _Inout_updates_z_(n):
   66 ;           for a NUL terminated array e.g. a string, of known length n bytes.
   67 ;       _In_reads_(n),_Out_writes_(n),_Inout_updates_(n):
   68 ;           for an array of n elements.
   69 ;       _In_reads_bytes_(n), _Out_writes_bytes_(n), _Inout_updates_bytes(n):
   70 ;           for a buffer of n-bytes.
   71 
   72 ; Please copy any additions and changes to the following compatability tables:
   73 ; sys/compat/freebsd32/syscalls.master
   74 
   75 ; #ifdef's, etc. may be included, and are copied to the output files.
   76 
   77 #include <sys/param.h>
   78 #include <sys/sysent.h>
   79 #include <sys/sysproto.h>
   80 
   81 ; Reserved/unimplemented system calls in the range 0-150 inclusive
   82 ; are reserved for use in future Berkeley releases.
   83 ; Additional system calls implemented in vendor and other
   84 ; redistributions should be placed in the reserved range at the end
   85 ; of the current calls.
   86 
   87 0       AUE_NULL        STD {
   88                 int nosys(void);
   89         } syscall nosys_args int
   90 1       AUE_EXIT        STD {
   91                 void sys_exit(
   92                     int rval
   93                 );
   94         } exit sys_exit_args void
   95 2       AUE_FORK        STD {
   96                 int fork(void);
   97         }
   98 3       AUE_READ        STD {
   99                 ssize_t read(
  100                     int fd,
  101                     _Out_writes_bytes_(nbyte) void *buf,
  102                     size_t nbyte
  103                 );
  104         }
  105 4       AUE_WRITE       STD {
  106                 ssize_t write(
  107                     int fd,
  108                     _In_reads_bytes_(nbyte) const void *buf,
  109                     size_t nbyte
  110                 );
  111         }
  112 5       AUE_OPEN_RWTC   STD {
  113                 int open(
  114                     _In_z_ const char *path,
  115                     int flags,
  116                     mode_t mode
  117                 );
  118         }
  119 ; XXX should be         { int open(const char *path, int flags, ...); }
  120 ; but we're not ready for varargs.
  121 6       AUE_CLOSE       STD {
  122                 int close(
  123                     int fd
  124                 );
  125         }
  126 7       AUE_WAIT4       STD {
  127                 int wait4(
  128                     int pid,
  129                     _Out_opt_ int *status,
  130                     int options,
  131                     _Out_opt_ struct rusage *rusage
  132                 );
  133         }
  134 8       AUE_CREAT       COMPAT {
  135                 int creat(
  136                     _In_z_ const char *path,
  137                     int mode
  138                 );
  139         }
  140 9       AUE_LINK        STD {
  141                 int link(
  142                     _In_z_ const char *path,
  143                     _In_z_ const char *link
  144                 );
  145         }
  146 10      AUE_UNLINK      STD {
  147                 int unlink(
  148                     _In_z_ const char *path
  149                 );
  150         }
  151 11      AUE_NULL        OBSOL   execv
  152 12      AUE_CHDIR       STD {
  153                 int chdir(
  154                     _In_z_ const char *path
  155                 );
  156         }
  157 13      AUE_FCHDIR      STD {
  158                 int fchdir(
  159                     int fd
  160                 );
  161         }
  162 14      AUE_MKNOD       COMPAT11 {
  163                 int mknod(
  164                     _In_z_ const char *path,
  165                     int mode,
  166                     uint32_t dev
  167                 );
  168         }
  169 15      AUE_CHMOD       STD {
  170                 int chmod(
  171                     _In_z_ const char *path,
  172                     mode_t mode
  173                 );
  174         }
  175 16      AUE_CHOWN       STD {
  176                 int chown(
  177                     _In_z_ const char *path,
  178                     int uid,
  179                     int gid
  180                 );
  181         }
  182 17      AUE_NULL        STD {
  183                 void *break(
  184                     _In_ char *nsize
  185                 );
  186         }
  187 18      AUE_GETFSSTAT   COMPAT4 {
  188                 int getfsstat(
  189                     _Out_writes_bytes_opt_(bufsize) struct ostatfs *buf,
  190                     long bufsize,
  191                     int mode
  192                 );
  193         }
  194 19      AUE_LSEEK       COMPAT {
  195                 long lseek(
  196                     int fd,
  197                     long offset,
  198                     int whence
  199                 );
  200         }
  201 20      AUE_GETPID      STD {
  202                 pid_t getpid(void);
  203         }
  204 21      AUE_MOUNT       STD {
  205                 int mount(
  206                     _In_z_ const char *type,
  207                     _In_z_ const char *path,
  208                     int flags,
  209                     _In_opt_ void *data
  210                 );
  211         }
  212 22      AUE_UMOUNT      STD {
  213                 int unmount(
  214                     _In_z_ const char *path,
  215                     int flags
  216                 );
  217         }
  218 23      AUE_SETUID      STD {
  219                 int setuid(
  220                     uid_t uid
  221                 );
  222         }
  223 24      AUE_GETUID      STD {
  224                 uid_t getuid(void);
  225         }
  226 25      AUE_GETEUID     STD {
  227                 uid_t geteuid(void);
  228         }
  229 26      AUE_PTRACE      STD {
  230                 int ptrace(
  231                     int req,
  232                     pid_t pid,
  233                     _Inout_opt_ caddr_t addr,
  234                     int data
  235                 );
  236         }
  237 27      AUE_RECVMSG     STD {
  238                 int recvmsg(
  239                     int s,
  240                     _Inout_ struct msghdr *msg,
  241                     int flags
  242                 );
  243         }
  244 28      AUE_SENDMSG     STD {
  245                 int sendmsg(
  246                     int s,
  247                     _In_ struct msghdr *msg,
  248                     int flags
  249                 );
  250         }
  251 29      AUE_RECVFROM    STD {
  252                 int recvfrom(
  253                     int s,
  254                     _Out_writes_bytes_(len) void *buf,
  255                     size_t len,
  256                     int flags,
  257                     _Out_writes_bytes_opt_(*fromlenaddr) struct sockaddr *from,
  258                     _Inout_opt_ __socklen_t *fromlenaddr
  259                 );
  260         }
  261 30      AUE_ACCEPT      STD {
  262                 int accept(
  263                     int s,
  264                     _Out_writes_bytes_opt_(*anamelen) struct sockaddr *name,
  265                     _Inout_opt_ __socklen_t *anamelen
  266                 );
  267         }
  268 31      AUE_GETPEERNAME STD {
  269                 int getpeername(
  270                     int fdes,
  271                     _Out_writes_bytes_(*alen) struct sockaddr *asa,
  272                     _Inout_opt_ __socklen_t *alen
  273                 );
  274         }
  275 32      AUE_GETSOCKNAME STD {
  276                 int getsockname(
  277                     int fdes,
  278                     _Out_writes_bytes_(*alen) struct sockaddr *asa,
  279                     _Inout_ __socklen_t *alen
  280                 );
  281         }
  282 33      AUE_ACCESS      STD {
  283                 int access(
  284                     _In_z_ const char *path,
  285                     int amode
  286                 );
  287         }
  288 34      AUE_CHFLAGS     STD {
  289                 int chflags(
  290                     _In_z_ const char *path,
  291                     u_long flags
  292                 );
  293         }
  294 35      AUE_FCHFLAGS    STD {
  295                 int fchflags(
  296                     int fd,
  297                     u_long flags
  298                 );
  299         }
  300 36      AUE_SYNC        STD {
  301                 int sync(void);
  302         }
  303 37      AUE_KILL        STD {
  304                 int kill(
  305                     int pid,
  306                     int signum
  307                 );
  308         }
  309 38      AUE_STAT        COMPAT {
  310                 int stat(
  311                     _In_z_ const char *path,
  312                     _Out_ struct ostat *ub
  313                 );
  314         }
  315 39      AUE_GETPPID     STD {
  316                 pid_t getppid(void);
  317         }
  318 40      AUE_LSTAT       COMPAT {
  319                 int lstat(
  320                     _In_z_ const char *path,
  321                     _Out_ struct ostat *ub
  322                 );
  323         }
  324 41      AUE_DUP         STD {
  325                 int dup(
  326                     u_int fd
  327                 );
  328         }
  329 42      AUE_PIPE        COMPAT10 {
  330                 int pipe(void);
  331         }
  332 43      AUE_GETEGID     STD {
  333                 gid_t getegid(void);
  334         }
  335 44      AUE_PROFILE     STD {
  336                 int profil(
  337                     _Out_writes_bytes_(size) char *samples,
  338                     size_t size,
  339                     size_t offset,
  340                     u_int scale
  341                 );
  342         }
  343 45      AUE_KTRACE      STD {
  344                 int ktrace(
  345                     _In_z_ const char *fname,
  346                     int ops,
  347                     int facs,
  348                     int pid
  349                 );
  350         }
  351 46      AUE_SIGACTION   COMPAT {
  352                 int sigaction(
  353                     int signum,
  354                     _In_opt_ struct osigaction *nsa,
  355                     _Out_opt_ struct osigaction *osa
  356                 );
  357         }
  358 47      AUE_GETGID      STD {
  359                 gid_t getgid(void);
  360         }
  361 48      AUE_SIGPROCMASK COMPAT {
  362                 int sigprocmask(
  363                     int how,
  364                     osigset_t mask
  365                 );
  366         }
  367 ; XXX note nonstandard (bogus) calling convention - the libc stub passes
  368 ; us the mask, not a pointer to it, and we return the old mask as the
  369 ; (int) return value.
  370 49      AUE_GETLOGIN    STD {
  371                 int getlogin(
  372                     _Out_writes_z_(namelen) char *namebuf,
  373                     u_int namelen
  374                 );
  375         }
  376 50      AUE_SETLOGIN    STD {
  377                 int setlogin(
  378                     _In_z_ const char *namebuf
  379                 );
  380         }
  381 51      AUE_ACCT        STD {
  382                 int acct(
  383                     _In_z_ const char *path
  384                 );
  385         }
  386 52      AUE_SIGPENDING  COMPAT {
  387                 int sigpending(void);
  388         }
  389 53      AUE_SIGALTSTACK STD {
  390                 int sigaltstack(
  391                     _In_opt_ stack_t *ss,
  392                     _Out_opt_ stack_t *oss
  393                 );
  394         }
  395 54      AUE_IOCTL       STD {
  396                 int ioctl(
  397                     int fd,
  398                     u_long com,
  399                     _Inout_opt_ char *data
  400                 );
  401         }
  402 55      AUE_REBOOT      STD {
  403                 int reboot(
  404                     int opt
  405                 );
  406         }
  407 56      AUE_REVOKE      STD {
  408                 int revoke(
  409                     _In_z_ const char *path
  410                 );
  411         }
  412 57      AUE_SYMLINK     STD {
  413                 int symlink(
  414                     _In_z_ const char *path,
  415                     _In_z_ const char *link
  416                 );
  417         }
  418 58      AUE_READLINK    STD {
  419                 ssize_t readlink(
  420                     _In_z_ const char *path,
  421                     _Out_writes_z_(count) char *buf,
  422                     size_t count
  423                 );
  424         }
  425 59      AUE_EXECVE      STD {
  426                 int execve(
  427                     _In_z_ const char *fname,
  428                     _In_z_ char **argv,
  429                     _In_z_ char **envv
  430                 );
  431         }
  432 60      AUE_UMASK       STD {
  433                 int umask(
  434                     mode_t newmask
  435                 );
  436         }
  437 61      AUE_CHROOT      STD {
  438                 int chroot(
  439                     _In_z_ const char *path
  440                 );
  441         }
  442 62      AUE_FSTAT       COMPAT {
  443                 int fstat(
  444                     int fd,
  445                     _Out_ struct ostat *sb
  446                 );
  447         }
  448 63      AUE_NULL        COMPAT {
  449                 int getkerninfo(
  450                     int op,
  451                     _Out_writes_bytes_opt(
  452                     *size) char *where,
  453                     _Inout_opt_ size_t *size,
  454                     int arg
  455                 );
  456         } getkerninfo getkerninfo_args int
  457 64      AUE_NULL        COMPAT {
  458                 int getpagesize(void);
  459         } getpagesize getpagesize_args int
  460 65      AUE_MSYNC       STD {
  461                 int msync(
  462                     _In_ void *addr,
  463                     size_t len,
  464                     int flags
  465                 );
  466         }
  467 66      AUE_VFORK       STD {
  468                 int vfork(void);
  469         }
  470 67      AUE_NULL        OBSOL   vread
  471 68      AUE_NULL        OBSOL   vwrite
  472 69      AUE_SBRK        STD {
  473                 int sbrk(
  474                     int incr
  475                 );
  476         }
  477 70      AUE_SSTK        STD {
  478                 int sstk(
  479                     int incr
  480                 );
  481         }
  482 71      AUE_MMAP        COMPAT {
  483                 void *mmap(
  484                     _In_ void *addr,
  485                     int len,
  486                     int prot,
  487                     int flags,
  488                     int fd,
  489                     long pos
  490                 );
  491         }
  492 72      AUE_O_VADVISE   COMPAT11 {
  493                 int vadvise(
  494                     int anom
  495                 );
  496         }
  497 73      AUE_MUNMAP      STD {
  498                 int munmap(
  499                     _In_ void *addr,
  500                     size_t len
  501                 );
  502         }
  503 74      AUE_MPROTECT    STD {
  504                 int mprotect(
  505                     _In_ void *addr,
  506                     size_t len,
  507                     int prot
  508                 );
  509         }
  510 75      AUE_MADVISE     STD {
  511                 int madvise(
  512                     _In_ void *addr,
  513                     size_t len,
  514                     int behav
  515                 );
  516         }
  517 76      AUE_NULL        OBSOL   vhangup
  518 77      AUE_NULL        OBSOL   vlimit
  519 78      AUE_MINCORE     STD {
  520                 int mincore(
  521                     _In_ const void *addr,
  522                     size_t len,
  523                     _Out_writes_bytes_(len/PAGE_SIZE) char *vec
  524                 );
  525         }
  526 79      AUE_GETGROUPS   STD {
  527                 int getgroups(
  528                     u_int gidsetsize,
  529                     _Out_writes_opt_(gidsetsize) gid_t *gidset
  530                 );
  531         }
  532 80      AUE_SETGROUPS   STD {
  533                 int setgroups(
  534                     u_int gidsetsize,
  535                     _In_reads_(gidsetsize) gid_t *gidset
  536                 );
  537         }
  538 81      AUE_GETPGRP     STD {
  539                 int getpgrp(void);
  540         }
  541 82      AUE_SETPGRP     STD {
  542                 int setpgid(
  543                     int pid,
  544                     int pgid
  545                 );
  546         }
  547 83      AUE_SETITIMER   STD {
  548                 int setitimer(
  549                     u_int which,
  550                     _In_ struct itimerval *itv,
  551                     _Out_opt_ struct itimerval *oitv
  552                 );
  553         }
  554 84      AUE_WAIT4       COMPAT {
  555                 int wait(void);
  556         }
  557 85      AUE_SWAPON      STD {
  558                 int swapon(
  559                     _In_z_ const char *name
  560                 );
  561         }
  562 86      AUE_GETITIMER   STD {
  563                 int getitimer(
  564                     u_int which,
  565                     _Out_ struct itimerval *itv
  566                 );
  567         }
  568 87      AUE_SYSCTL      COMPAT {
  569                 int gethostname(
  570                     _Out_writes_z_(len) char *hostname,
  571                     u_int len
  572                 );
  573         } gethostname gethostname_args int
  574 88      AUE_SYSCTL      COMPAT {
  575                 int sethostname(
  576                     _In_reads_z_(len) char *hostname,
  577                     u_int len
  578                 );
  579         } sethostname sethostname_args int
  580 89      AUE_GETDTABLESIZE       STD {
  581                 int getdtablesize(void);
  582         }
  583 90      AUE_DUP2        STD {
  584                 int dup2(
  585                     u_int from,
  586                     u_int to
  587                 );
  588         }
  589 91      AUE_NULL        UNIMPL  getdopt
  590 92      AUE_FCNTL       STD {
  591                 int fcntl(
  592                     int fd,
  593                     int cmd,
  594                     long arg
  595                 );
  596         }
  597 ; XXX should be { int fcntl(int fd, int cmd, ...); }
  598 ; but we're not ready for varargs.
  599 93      AUE_SELECT      STD {
  600                 int select(
  601                     int nd,
  602                     _Inout_opt_ fd_set *in,
  603                     _Inout_opt_ fd_set *ou,
  604                     _Inout_opt_ fd_set *ex,
  605                     _In_opt_ struct timeval *tv
  606                 );
  607         }
  608 94      AUE_NULL        UNIMPL  setdopt
  609 95      AUE_FSYNC       STD {
  610                 int fsync(
  611                     int fd
  612                 );
  613         }
  614 96      AUE_SETPRIORITY STD {
  615                 int setpriority(
  616                     int which,
  617                     int who,
  618                     int prio
  619                 );
  620         }
  621 97      AUE_SOCKET      STD {
  622                 int socket(
  623                     int domain,
  624                     int type,
  625                     int protocol
  626                 );
  627         }
  628 98      AUE_CONNECT     STD {
  629                 int connect(
  630                     int s,
  631                     _In_reads_bytes_(namelen) const struct sockaddr *name,
  632                     int namelen
  633                 );
  634         }
  635 99      AUE_ACCEPT      COMPAT|NOARGS {
  636                 int accept(
  637                     int s,
  638                     _Out_writes_bytes_opt_(*anamelen) struct sockaddr *name,
  639                     int *anamelen
  640                 );
  641         } accept accept_args int
  642 100     AUE_GETPRIORITY STD {
  643                 int getpriority(
  644                     int which,
  645                     int who
  646                 );
  647         }
  648 101     AUE_SEND        COMPAT {
  649                 int send(
  650                     int s,
  651                     _In_reads_bytes_(len) const void *buf,
  652                     int len,
  653                     int flags
  654                 );
  655         }
  656 102     AUE_RECV        COMPAT {
  657                 int recv(
  658                     int s,
  659                     _Out_writes_bytes_(len) void *buf,
  660                     int len,
  661                     int flags
  662                 );
  663         }
  664 103     AUE_SIGRETURN   COMPAT {
  665                 int sigreturn(
  666                     _In_ struct osigcontext *sigcntxp
  667                 );
  668         }
  669 104     AUE_BIND        STD {
  670                 int bind(
  671                     int s,
  672                     _In_reads_bytes_(namelen) const struct sockaddr *name,
  673                     int namelen
  674                 );
  675         }
  676 105     AUE_SETSOCKOPT  STD {
  677                 int setsockopt(
  678                     int s,
  679                     int level,
  680                     int name,
  681                     _In_reads_bytes_opt_(valsize) const void *val,
  682                     int valsize
  683                 );
  684         }
  685 106     AUE_LISTEN      STD {
  686                 int listen(
  687                     int s,
  688                     int backlog
  689                 );
  690         }
  691 107     AUE_NULL        OBSOL   vtimes
  692 108     AUE_NULL        COMPAT {
  693                 int sigvec(
  694                     int signum,
  695                     _In_opt_ struct sigvec *nsv,
  696                     _Out_opt_ struct sigvec *osv
  697                 );
  698         }
  699 109     AUE_NULL        COMPAT {
  700                 int sigblock(
  701                     int mask
  702                 );
  703         }
  704 110     AUE_NULL        COMPAT {
  705                 int sigsetmask(
  706                     int mask
  707                 );
  708         }
  709 111     AUE_NULL        COMPAT {
  710                 int sigsuspend(
  711                     osigset_t mask
  712                 );
  713         }
  714 ; XXX note nonstandard (bogus) calling convention - the libc stub passes
  715 ; us the mask, not a pointer to it.
  716 112     AUE_NULL        COMPAT {
  717                 int sigstack(
  718                     _In_opt_ struct sigstack *nss,
  719                     _Out_opt_ struct sigstack *oss
  720                 );
  721         }
  722 113     AUE_RECVMSG     COMPAT {
  723                 int recvmsg(
  724                     int s,
  725                     _Inout_ struct omsghdr *msg,
  726                     int flags
  727                 );
  728         }
  729 114     AUE_SENDMSG     COMPAT {
  730                 int sendmsg(
  731                     int s,
  732                     _In_ const void *msg,
  733                     int flags
  734                 );
  735         }
  736 115     AUE_NULL        OBSOL   vtrace
  737 116     AUE_GETTIMEOFDAY        STD {
  738                 int gettimeofday(
  739                     _Out_ struct timeval *tp,
  740                     _Out_opt_ struct timezone *tzp
  741                 );
  742         }
  743 117     AUE_GETRUSAGE   STD {
  744                 int getrusage(
  745                     int who,
  746                     _Out_ struct rusage *rusage
  747                 );
  748         }
  749 118     AUE_GETSOCKOPT  STD {
  750                 int getsockopt(
  751                     int s,
  752                     int level,
  753                     int name,
  754                     _Out_writes_bytes_opt_(*avalsize) void *val,
  755                     _Inout_  int *avalsize
  756                 );
  757         }
  758 119     AUE_NULL        UNIMPL  resuba (BSD/OS 2.x)
  759 120     AUE_READV       STD {
  760                 int readv(
  761                     int fd,
  762                     _Inout_updates_(iovcnt) struct iovec *iovp,
  763                     u_int iovcnt
  764                 );
  765         }
  766 121     AUE_WRITEV      STD {
  767                 int writev(
  768                     int fd,
  769                     _In_reads_opt_(iovcnt) struct iovec *iovp,
  770                     u_int iovcnt
  771                 );
  772         }
  773 122     AUE_SETTIMEOFDAY        STD {
  774                 int settimeofday(
  775                     _In_ struct timeval *tv,
  776                     _In_opt_ struct timezone *tzp
  777                 );
  778         }
  779 123     AUE_FCHOWN      STD {
  780                 int fchown(
  781                     int fd,
  782                     int uid,
  783                     int gid
  784                 );
  785         }
  786 124     AUE_FCHMOD      STD {
  787                 int fchmod(
  788                     int fd,
  789                     mode_t mode
  790                 );
  791         }
  792 125     AUE_RECVFROM    COMPAT|NOARGS {
  793                 int recvfrom(
  794                     int s,
  795                     _Out_writes_(len) void *buf,
  796                     size_t len,
  797                     int flags,
  798                     _Out_writes_bytes_(*fromlenaddr) struct sockaddr *from,
  799                     _Inout_ int *fromlenaddr
  800                 );
  801         } recvfrom recvfrom_args int
  802 126     AUE_SETREUID    STD {
  803                 int setreuid(
  804                     int ruid,
  805                     int euid
  806                 );
  807         }
  808 127     AUE_SETREGID    STD {
  809                 int setregid(
  810                     int rgid,
  811                     int egid
  812                 );
  813         }
  814 128     AUE_RENAME      STD {
  815                 int rename(
  816                     _In_z_ const char *from,
  817                     _In_z_ const char *to
  818                 );
  819         }
  820 129     AUE_TRUNCATE    COMPAT {
  821                 int truncate(
  822                     _In_z_ const char *path,
  823                     long length
  824                 );
  825         }
  826 130     AUE_FTRUNCATE   COMPAT {
  827                 int ftruncate(
  828                     int fd,
  829                     long length
  830                 );
  831         }
  832 131     AUE_FLOCK       STD {
  833                 int flock(
  834                     int fd,
  835                     int how
  836                 );
  837         }
  838 132     AUE_MKFIFO      STD {
  839                 int mkfifo(
  840                     _In_z_ const char *path,
  841                     mode_t mode
  842                 );
  843         }
  844 133     AUE_SENDTO      STD {
  845                 int sendto(
  846                     int s,
  847                     _In_reads_bytes_(len) const void *buf,
  848                     size_t len,
  849                     int flags,
  850                     _In_reads_bytes_opt_(tolen) const struct sockaddr *to,
  851                     int tolen
  852                 );
  853         }
  854 134     AUE_SHUTDOWN    STD {
  855                 int shutdown(
  856                     int s,
  857                     int how
  858                 );
  859         }
  860 135     AUE_SOCKETPAIR  STD {
  861                 int socketpair(
  862                     int domain,
  863                     int type,
  864                     int protocol,
  865                     _Out_writes_(2) int *rsv
  866                 );
  867         }
  868 136     AUE_MKDIR       STD {
  869                 int mkdir(
  870                     _In_z_ const char *path,
  871                     mode_t mode
  872                 );
  873         }
  874 137     AUE_RMDIR       STD {
  875                 int rmdir(
  876                     _In_z_ const char *path
  877                 );
  878         }
  879 138     AUE_UTIMES      STD {
  880                 int utimes(
  881                     _In_z_ const char *path,
  882                     _In_ struct timeval *tptr
  883                 );
  884         }
  885 139     AUE_NULL        OBSOL   4.2 sigreturn
  886 140     AUE_ADJTIME     STD {
  887                 int adjtime(
  888                     _In_ struct timeval *delta,
  889                     _Out_opt_ struct timeval *olddelta
  890                 );
  891         }
  892 141     AUE_GETPEERNAME COMPAT {
  893                 int getpeername(
  894                     int fdes,
  895                     _Out_writes_bytes_(*alen) struct sockaddr *asa,
  896                     _Inout_opt_ int *alen
  897                 );
  898         }
  899 142     AUE_SYSCTL      COMPAT {
  900                 long gethostid(void);
  901         }
  902 143     AUE_SYSCTL      COMPAT {
  903                 int sethostid(
  904                     long hostid
  905                 );
  906         }
  907 144     AUE_GETRLIMIT   COMPAT {
  908                 int getrlimit(
  909                     u_int which,
  910                     _Out_ struct orlimit *rlp
  911                 );
  912         }
  913 145     AUE_SETRLIMIT   COMPAT {
  914                 int setrlimit(
  915                     u_int which,
  916                     _Out_ struct orlimit *rlp
  917                 );
  918         }
  919 146     AUE_KILLPG      COMPAT {
  920                 int killpg(
  921                     int pgid,
  922                     int signum
  923                 );
  924         }
  925 147     AUE_SETSID      STD {
  926                 int setsid(void);
  927         }
  928 148     AUE_QUOTACTL    STD {
  929                 int quotactl(
  930                     _In_z_ const char *path,
  931                     int cmd,
  932                     int uid,
  933                     _In_ void *arg
  934                 );
  935         }
  936 149     AUE_O_QUOTA     COMPAT {
  937                 int quota(void);
  938         }
  939 150     AUE_GETSOCKNAME COMPAT|NOARGS {
  940                 int getsockname(
  941                     int fdec,
  942                     _Out_writes_bytes_(*alen) struct sockaddr *asa,
  943                     _Inout_ int *alen
  944                 );
  945         } getsockname getsockname_args int
  946 
  947 ; Syscalls 151-180 inclusive are reserved for vendor-specific
  948 ; system calls.  (This includes various calls added for compatibity
  949 ; with other Unix variants.)
  950 ; Some of these calls are now supported by BSD...
  951 151     AUE_NULL        UNIMPL  sem_lock (BSD/OS 2.x)
  952 152     AUE_NULL        UNIMPL  sem_wakeup (BSD/OS 2.x)
  953 153     AUE_NULL        UNIMPL  asyncdaemon (BSD/OS 2.x)
  954 ; 154 is initialised by the NLM code, if present.
  955 154     AUE_NULL        NOSTD {
  956                 int nlm_syscall(
  957                     int debug_level,
  958                     int grace_period,
  959                     int addr_count,
  960                     _In_reads_(addr_count) char **addrs
  961                 );
  962         }
  963 ; 155 is initialized by the NFS code, if present.
  964 155     AUE_NFS_SVC     NOSTD {
  965                 int nfssvc(
  966                     int flag,
  967                     _In_ void *argp
  968                 );
  969         }
  970 156     AUE_GETDIRENTRIES       COMPAT {
  971                 int getdirentries(
  972                     int fd,
  973                     _Out_writes_bytes_(count) char *buf,
  974                     u_int count,
  975                     _Out_ long *basep
  976                 );
  977         }
  978 157     AUE_STATFS      COMPAT4 {
  979                 int statfs(
  980                     _In_z_ const char *path,
  981                     _Out_ struct ostatfs *buf
  982                 );
  983         }
  984 158     AUE_FSTATFS     COMPAT4 {
  985                 int fstatfs(
  986                     int fd,
  987                     _Out_ struct ostatfs *buf
  988                 );
  989         }
  990 159     AUE_NULL        UNIMPL  nosys
  991 160     AUE_LGETFH      STD {
  992                 int lgetfh(
  993                     _In_z_ const char *fname,
  994                     _Out_ struct fhandle *fhp
  995                 );
  996         }
  997 161     AUE_NFS_GETFH   STD {
  998                 int getfh(
  999                     _In_z_ const char *fname,
 1000                     _Out_ struct fhandle *fhp
 1001                 );
 1002         }
 1003 162     AUE_SYSCTL      COMPAT4 {
 1004                 int getdomainname(
 1005                     _Out_writes_z_(len) char *domainname,
 1006                     int len
 1007                 );
 1008         }
 1009 163     AUE_SYSCTL      COMPAT4 {
 1010                 int setdomainname(
 1011                     _In_reads_z_(len) char *domainname,
 1012                     int len
 1013                 );
 1014         }
 1015 164     AUE_NULL        COMPAT4 {
 1016                 int uname(
 1017                     _Out_ struct utsname *name
 1018                 );
 1019         }
 1020 165     AUE_SYSARCH     STD {
 1021                 int sysarch(
 1022                     int op,
 1023                     _In_z_ char *parms
 1024                 );
 1025         }
 1026 166     AUE_RTPRIO      STD {
 1027                 int rtprio(
 1028                     int function,
 1029                     pid_t pid,
 1030                     _Inout_ struct rtprio *rtp
 1031                 );
 1032         }
 1033 167     AUE_NULL        UNIMPL  nosys
 1034 168     AUE_NULL        UNIMPL  nosys
 1035 169     AUE_SEMSYS      NOSTD {
 1036                 int semsys(
 1037                     int which,
 1038                     int a2,
 1039                     int a3,
 1040                     int a4,
 1041                     int a5
 1042                 );
 1043         }
 1044 ; XXX should be { int semsys(int which, ...); }
 1045 170     AUE_MSGSYS      NOSTD {
 1046                 int msgsys(
 1047                     int which,
 1048                     int a2,
 1049                     int a3,
 1050                     int a4,
 1051                     int a5,
 1052                     int a6
 1053                 );
 1054         }
 1055 ; XXX should be { int msgsys(int which, ...); }
 1056 171     AUE_SHMSYS      NOSTD {
 1057                 int shmsys(
 1058                     int which,
 1059                     int a2,
 1060                     int a3,
 1061                     int a4
 1062                 );
 1063         }
 1064 ; XXX should be { int shmsys(int which, ...); }
 1065 172     AUE_NULL        UNIMPL  nosys
 1066 173     AUE_PREAD       COMPAT6 {
 1067                 ssize_t pread(
 1068                     int fd,
 1069                     _Out_writes_bytes_(nbyte) void *buf,
 1070                     size_t nbyte,
 1071                     int pad,
 1072                     off_t offset
 1073                 );
 1074         }
 1075 174     AUE_PWRITE      COMPAT6 {
 1076                 ssize_t pwrite(
 1077                     int fd,
 1078                     _In_reads_bytes_(nbyte) const void *buf,
 1079                     size_t nbyte,
 1080                     int pad,
 1081                     off_t offset
 1082                 );
 1083         }
 1084 175     AUE_SETFIB      STD {
 1085                 int setfib(
 1086                     int fibnum
 1087                 );
 1088         }
 1089 176     AUE_NTP_ADJTIME STD {
 1090                 int ntp_adjtime(
 1091                     _Inout_ struct timex *tp
 1092                 );
 1093         }
 1094 177     AUE_NULL        UNIMPL  sfork (BSD/OS 2.x)
 1095 178     AUE_NULL        UNIMPL  getdescriptor (BSD/OS 2.x)
 1096 179     AUE_NULL        UNIMPL  setdescriptor (BSD/OS 2.x)
 1097 180     AUE_NULL        UNIMPL  nosys
 1098 
 1099 ; Syscalls 181-199 are used by/reserved for BSD
 1100 181     AUE_SETGID      STD {
 1101                 int setgid(
 1102                     gid_t gid
 1103                 );
 1104         }
 1105 182     AUE_SETEGID     STD {
 1106                 int setegid(
 1107                     gid_t egid
 1108                 );
 1109         }
 1110 183     AUE_SETEUID     STD {
 1111                 int seteuid(
 1112                     uid_t euid
 1113                 );
 1114         }
 1115 184     AUE_NULL        OBSOL   lfs_bmapv
 1116 185     AUE_NULL        OBSOL   lfs_markv
 1117 186     AUE_NULL        OBSOL   lfs_segclean
 1118 187     AUE_NULL        OBSOL   lfs_segwait
 1119 188     AUE_STAT        COMPAT11 {
 1120                 int stat(
 1121                     _In_z_ const char *path,
 1122                     _Out_ struct freebsd11_stat *ub
 1123                 );
 1124         }
 1125 189     AUE_FSTAT       COMPAT11 {
 1126                 int fstat(
 1127                     int fd,
 1128                     _Out_ struct freebsd11_stat *sb
 1129                 );
 1130         }
 1131 190     AUE_LSTAT       COMPAT11 {
 1132                 int lstat(
 1133                     _In_z_ const char *path,
 1134                     _Out_ struct freebsd11_stat *ub
 1135                 );
 1136         }
 1137 191     AUE_PATHCONF    STD {
 1138                 int pathconf(
 1139                     _In_z_ const char *path,
 1140                     int name
 1141                 );
 1142         }
 1143 192     AUE_FPATHCONF   STD {
 1144                 int fpathconf(
 1145                     int fd,
 1146                     int name
 1147                 );
 1148         }
 1149 193     AUE_NULL        UNIMPL  nosys
 1150 194     AUE_GETRLIMIT   STD {
 1151                 int getrlimit(
 1152                     u_int which,
 1153                     _Out_ struct rlimit *rlp
 1154                 );
 1155         } getrlimit __getrlimit_args int
 1156 195     AUE_SETRLIMIT   STD {
 1157                 int setrlimit(
 1158                     u_int which,
 1159                     _In_ struct rlimit *rlp
 1160                 );
 1161         } setrlimit __setrlimit_args int
 1162 196     AUE_GETDIRENTRIES       COMPAT11 {
 1163                 int getdirentries(
 1164                     int fd,
 1165                     _Out_writes_bytes_(count) char *buf,
 1166                     u_int count,
 1167                     _Out_ long *basep
 1168                 );
 1169         }
 1170 197     AUE_MMAP        COMPAT6 {
 1171                 void *mmap(
 1172                     _In_ void *addr,
 1173                     size_t len,
 1174                     int prot,
 1175                     int flags,
 1176                     int fd,
 1177                     int pad,
 1178                     off_t pos
 1179                 );
 1180         }
 1181 198     AUE_NULL        NOPROTO {
 1182                 int nosys(void);
 1183         } __syscall __syscall_args int
 1184 199     AUE_LSEEK       COMPAT6 {
 1185                 off_t lseek(
 1186                     int fd,
 1187                     int pad,
 1188                     off_t offset,
 1189                     int whence
 1190                 );
 1191         }
 1192 200     AUE_TRUNCATE    COMPAT6 {
 1193                 int truncate(
 1194                     _In_z_ const char *path,
 1195                     int pad,
 1196                     off_t length
 1197                 );
 1198         }
 1199 201     AUE_FTRUNCATE   COMPAT6 {
 1200                 int ftruncate(
 1201                     int fd,
 1202                     int pad,
 1203                     off_t length
 1204                 );
 1205         }
 1206 202     AUE_SYSCTL      STD {
 1207                 int __sysctl(
 1208                     _In_reads_(namelen) int *name,
 1209                     u_int namelen,
 1210                     _Out_writes_bytes_opt_(*oldlenp) void *old,
 1211                     _Inout_opt_ size_t *oldlenp,
 1212                     _In_reads_bytes_opt_(newlen) void *new,
 1213                     size_t newlen
 1214                 );
 1215         } __sysctl sysctl_args int
 1216 203     AUE_MLOCK       STD {
 1217                 int mlock(
 1218                     _In_ const void *addr,
 1219                     size_t len
 1220                 );
 1221         }
 1222 204     AUE_MUNLOCK     STD {
 1223                 int munlock(
 1224                     _In_ const void *addr,
 1225                     size_t len
 1226                 );
 1227         }
 1228 205     AUE_UNDELETE    STD {
 1229                 int undelete(
 1230                     _In_z_ const char *path
 1231                 );
 1232         }
 1233 206     AUE_FUTIMES     STD {
 1234                 int futimes(
 1235                     int fd,
 1236                     _In_reads_(2) struct timeval *tptr
 1237                 );
 1238         }
 1239 207     AUE_GETPGID     STD {
 1240                 int getpgid(
 1241                     pid_t pid
 1242                 );
 1243         }
 1244 208     AUE_NULL        UNIMPL  nosys
 1245 209     AUE_POLL        STD {
 1246                 int poll(
 1247                     _Inout_updates_(nfds) struct pollfd *fds,
 1248                     u_int nfds,
 1249                     int timeout
 1250                 );
 1251         }
 1252 ;
 1253 ; The following are reserved for loadable syscalls
 1254 ;
 1255 210     AUE_NULL        NODEF|NOTSTATIC lkmnosys lkmnosys nosys_args int
 1256 211     AUE_NULL        NODEF|NOTSTATIC lkmnosys lkmnosys nosys_args int
 1257 212     AUE_NULL        NODEF|NOTSTATIC lkmnosys lkmnosys nosys_args int
 1258 213     AUE_NULL        NODEF|NOTSTATIC lkmnosys lkmnosys nosys_args int
 1259 214     AUE_NULL        NODEF|NOTSTATIC lkmnosys lkmnosys nosys_args int
 1260 215     AUE_NULL        NODEF|NOTSTATIC lkmnosys lkmnosys nosys_args int
 1261 216     AUE_NULL        NODEF|NOTSTATIC lkmnosys lkmnosys nosys_args int
 1262 217     AUE_NULL        NODEF|NOTSTATIC lkmnosys lkmnosys nosys_args int
 1263 218     AUE_NULL        NODEF|NOTSTATIC lkmnosys lkmnosys nosys_args int
 1264 219     AUE_NULL        NODEF|NOTSTATIC lkmnosys lkmnosys nosys_args int
 1265 
 1266 220     AUE_SEMCTL      COMPAT7|NOSTD {
 1267                 int __semctl(
 1268                     int semid,
 1269                     int semnum,
 1270                     int cmd,
 1271                     union semun_old *arg
 1272                 );
 1273         }
 1274 221     AUE_SEMGET      NOSTD {
 1275                 int semget(
 1276                     key_t key,
 1277                     int nsems,
 1278                     int semflg
 1279                 );
 1280         }
 1281 222     AUE_SEMOP       NOSTD {
 1282                 int semop(
 1283                     int semid,
 1284                     _In_reads_(nsops) struct sembuf *sops,
 1285                     size_t nsops
 1286                 );
 1287         }
 1288 223     AUE_NULL        OBSOL   semconfig
 1289 224     AUE_MSGCTL      COMPAT7|NOSTD {
 1290                 int msgctl(
 1291                     int msqid,
 1292                     int cmd,
 1293                     struct msqid_ds_old *buf
 1294                 );
 1295         }
 1296 225     AUE_MSGGET      NOSTD {
 1297                 int msgget(
 1298                     key_t key,
 1299                     int msgflg
 1300                 );
 1301         }
 1302 226     AUE_MSGSND      NOSTD {
 1303                 int msgsnd(
 1304                     int msqid,
 1305                     _In_reads_bytes_(msgsz) const void *msgp,
 1306                     size_t msgsz,
 1307                     int msgflg
 1308                 );
 1309         }
 1310 227     AUE_MSGRCV      NOSTD {
 1311                 ssize_t msgrcv(
 1312                     int msqid,
 1313                     _Out_writes_bytes_(msgsz) void *msgp,
 1314                     size_t msgsz,
 1315                     long msgtyp,
 1316                     int msgflg
 1317                 );
 1318         }
 1319 228     AUE_SHMAT       NOSTD {
 1320                 void *shmat(
 1321                     int shmid,
 1322                     _In_ const void *shmaddr,
 1323                     int shmflg
 1324                 );
 1325         }
 1326 229     AUE_SHMCTL      COMPAT7|NOSTD {
 1327                 int shmctl(
 1328                     int shmid,
 1329                     int cmd,
 1330                     struct shmid_ds_old *buf
 1331                 );
 1332         }
 1333 230     AUE_SHMDT       NOSTD {
 1334                 int shmdt(
 1335                     _In_ const void *shmaddr
 1336                 );
 1337         }
 1338 231     AUE_SHMGET      NOSTD {
 1339                 int shmget(
 1340                     key_t key,
 1341                     size_t size,
 1342                     int shmflg
 1343                 );
 1344         }
 1345 232     AUE_NULL        STD {
 1346                 int clock_gettime(
 1347                     clockid_t clock_id,
 1348                     _Out_ struct timespec *tp
 1349                 );
 1350         }
 1351 233     AUE_CLOCK_SETTIME       STD {
 1352                 int clock_settime(
 1353                     clockid_t clock_id,
 1354                     _In_ const struct timespec *tp
 1355                 );
 1356         }
 1357 234     AUE_NULL        STD {
 1358                 int clock_getres(
 1359                     clockid_t clock_id,
 1360                     _Out_ struct timespec *tp
 1361                 );
 1362         }
 1363 235     AUE_NULL        STD {
 1364                 int ktimer_create(
 1365                     clockid_t clock_id,
 1366                     _In_ struct sigevent *evp,
 1367                     _Out_ int *timerid
 1368                 );
 1369         }
 1370 236     AUE_NULL        STD {
 1371                 int ktimer_delete(
 1372                     int timerid
 1373                 );
 1374         }
 1375 237     AUE_NULL        STD {
 1376                 int ktimer_settime(
 1377                     int timerid,
 1378                     int flags,
 1379                     _In_ const struct itimerspec *value,
 1380                     _Out_opt_ struct itimerspec *ovalue
 1381                 );
 1382         }
 1383 238     AUE_NULL        STD {
 1384                 int ktimer_gettime(
 1385                     int timerid,
 1386                     _Out_ struct itimerspec *value
 1387                 );
 1388         }
 1389 239     AUE_NULL        STD {
 1390                 int ktimer_getoverrun(
 1391                     int timerid
 1392                 );
 1393         }
 1394 240     AUE_NULL        STD {
 1395                 int nanosleep(
 1396                     _In_ const struct timespec *rqtp,
 1397                     _Out_opt_ struct timespec *rmtp
 1398                 );
 1399         }
 1400 241     AUE_NULL        STD {
 1401                 int ffclock_getcounter(
 1402                     _Out_ ffcounter *ffcount
 1403                 );
 1404         }
 1405 242     AUE_NULL        STD {
 1406                 int ffclock_setestimate(
 1407                     _In_ struct ffclock_estimate *cest
 1408                 );
 1409         }
 1410 243     AUE_NULL        STD {
 1411                 int ffclock_getestimate(
 1412                     _Out_ struct ffclock_estimate *cest
 1413                 );
 1414         }
 1415 244     AUE_NULL        STD {
 1416                 int clock_nanosleep(
 1417                     clockid_t clock_id,
 1418                     int flags,
 1419                     _In_ const struct timespec *rqtp,
 1420                     _Out_opt_ struct timespec *rmtp
 1421                 );
 1422         }
 1423 245-246 AUE_NULL        UNIMPL  nosys
 1424 247     AUE_NULL        STD {
 1425                 int clock_getcpuclockid2(
 1426                     id_t id,
 1427                     int which,
 1428                     _Out_ clockid_t *clock_id
 1429                 );
 1430         }
 1431 248     AUE_NULL        STD {
 1432                 int ntp_gettime(
 1433                     _Out_ struct ntptimeval *ntvp
 1434                 );
 1435         }
 1436 249     AUE_NULL        UNIMPL  nosys
 1437 ; syscall numbers initially used in OpenBSD
 1438 250     AUE_MINHERIT    STD {
 1439                 int minherit(
 1440                     _In_ void *addr,
 1441                     size_t len,
 1442                     int inherit
 1443                 );
 1444         }
 1445 251     AUE_RFORK       STD {
 1446                 int rfork(
 1447                     int flags
 1448                 );
 1449         }
 1450 252     AUE_POLL        OBSOL   openbsd_poll
 1451 253     AUE_ISSETUGID   STD {
 1452                 int issetugid(void);
 1453         }
 1454 254     AUE_LCHOWN      STD {
 1455                 int lchown(
 1456                     _In_z_ const char *path,
 1457                     int uid,
 1458                     int gid
 1459                 );
 1460         }
 1461 255     AUE_AIO_READ    STD {
 1462                 int aio_read(
 1463                     _Inout_ struct aiocb *aiocbp
 1464                 );
 1465         }
 1466 256     AUE_AIO_WRITE   STD {
 1467                 int aio_write(
 1468                     _Inout_ struct aiocb *aiocbp
 1469                 );
 1470         }
 1471 257     AUE_LIO_LISTIO  STD {
 1472                 int lio_listio(
 1473                     int mode,
 1474                     _Inout_updates_(nent) struct aiocb* const *acb_list,
 1475                     int nent,
 1476                     _In_opt_ struct sigevent *sig
 1477                 );
 1478         }
 1479 258-271 AUE_NULL        UNIMPL  nosys
 1480 272     AUE_O_GETDENTS  COMPAT11 {
 1481                 int getdents(
 1482                     int fd,
 1483                     _Out_writes_bytes_(count) char *buf,
 1484                     size_t count
 1485                 );
 1486         }
 1487 273     AUE_NULL        UNIMPL  nosys
 1488 274     AUE_LCHMOD      STD {
 1489                 int lchmod(
 1490                     _In_z_ const char *path,
 1491                     mode_t mode
 1492                 );
 1493         }
 1494 275     AUE_NULL        OBSOL   netbsd_lchown
 1495 276     AUE_LUTIMES     STD {
 1496                 int lutimes(
 1497                     _In_z_ const char *path,
 1498                     _In_ struct timeval *tptr
 1499                 );
 1500         }
 1501 277     AUE_NULL        OBSOL   netbsd_msync
 1502 278     AUE_STAT        COMPAT11 {
 1503                 int nstat(
 1504                     _In_z_ const char *path,
 1505                     _Out_ struct nstat *ub
 1506                 );
 1507         }
 1508 279     AUE_FSTAT       COMPAT11 {
 1509                 int nfstat(
 1510                     int fd,
 1511                     _Out_ struct nstat *sb
 1512                 );
 1513         }
 1514 280     AUE_LSTAT       COMPAT11 {
 1515                 int nlstat(
 1516                     _In_z_ const char *path,
 1517                     _Out_ struct nstat *ub
 1518                 );
 1519         }
 1520 281-288 AUE_NULL        UNIMPL  nosys
 1521 289     AUE_PREADV      STD {
 1522                 ssize_t preadv(
 1523                     int fd,
 1524                     _In_reads_(iovcnt) struct iovec *iovp,
 1525                     u_int iovcnt,
 1526                     off_t offset
 1527                 );
 1528         }
 1529 290     AUE_PWRITEV     STD {
 1530                 ssize_t pwritev(
 1531                     int fd,
 1532                     _In_reads_(iovcnt) struct iovec *iovp,
 1533                     u_int iovcnt,
 1534                     off_t offset
 1535                 );
 1536         }
 1537 291-296 AUE_NULL        UNIMPL  nosys
 1538 297     AUE_FHSTATFS    COMPAT4 {
 1539                 int fhstatfs(
 1540                     _In_ const struct fhandle *u_fhp,
 1541                     _Out_ struct ostatfs *buf
 1542                 );
 1543         }
 1544 298     AUE_FHOPEN      STD {
 1545                 int fhopen(
 1546                     _In_ const struct fhandle *u_fhp,
 1547                     int flags
 1548                 );
 1549         }
 1550 299     AUE_FHSTAT      COMPAT11 {
 1551                 int fhstat(
 1552                     _In_ const struct fhandle *u_fhp,
 1553                     _Out_ struct freebsd11_stat *sb
 1554                 );
 1555         }
 1556 300     AUE_NULL        STD {
 1557                 int modnext(
 1558                     int modid
 1559                 );
 1560         }
 1561 301     AUE_NULL        STD {
 1562                 int modstat(
 1563                     int modid,
 1564                     _Out_ struct module_stat* stat
 1565                 );
 1566         }
 1567 302     AUE_NULL        STD {
 1568                 int modfnext(
 1569                     int modid
 1570                 );
 1571         }
 1572 303     AUE_NULL        STD {
 1573                 int modfind(
 1574                     _In_z_ const char *name
 1575                 );
 1576         }
 1577 304     AUE_MODLOAD     STD {
 1578                 int kldload(
 1579                     _In_z_ const char *file
 1580                 );
 1581         }
 1582 305     AUE_MODUNLOAD   STD {
 1583                 int kldunload(
 1584                     int fileid
 1585                 );
 1586         }
 1587 306     AUE_NULL        STD {
 1588                 int kldfind(
 1589                     _In_z_ const char *file
 1590                 );
 1591         }
 1592 307     AUE_NULL        STD {
 1593                 int kldnext(
 1594                     int fileid
 1595                 );
 1596         }
 1597 308     AUE_NULL        STD {
 1598                 int kldstat(
 1599                     int fileid,
 1600                     _Out_ struct kld_file_stat *stat
 1601                 );
 1602         }
 1603 309     AUE_NULL        STD {
 1604                 int kldfirstmod(
 1605                     int fileid
 1606                 );
 1607         }
 1608 310     AUE_GETSID      STD {
 1609                 int getsid(
 1610                     pid_t pid
 1611                 );
 1612         }
 1613 311     AUE_SETRESUID   STD {
 1614                 int setresuid(
 1615                     uid_t ruid,
 1616                     uid_t euid,
 1617                     uid_t suid
 1618                 );
 1619         }
 1620 312     AUE_SETRESGID   STD {
 1621                 int setresgid(
 1622                     gid_t rgid,
 1623                     gid_t egid,
 1624                     gid_t sgid
 1625                 );
 1626         }
 1627 313     AUE_NULL        OBSOL   signanosleep
 1628 314     AUE_AIO_RETURN  STD {
 1629                 ssize_t aio_return(
 1630                     _Inout_ struct aiocb *aiocbp
 1631                 );
 1632         }
 1633 315     AUE_AIO_SUSPEND STD {
 1634                 int aio_suspend(
 1635                     _Inout_updates_(nent) struct aiocb * const * aiocbp,
 1636                     int nent,
 1637                     _In_opt_ const struct timespec *timeout
 1638                 );
 1639         }
 1640 316     AUE_AIO_CANCEL  STD {
 1641                 int aio_cancel(
 1642                     int fd,
 1643                     _In_opt_ struct aiocb *aiocbp
 1644                 );
 1645         }
 1646 317     AUE_AIO_ERROR   STD {
 1647                 int aio_error(
 1648                     _In_ struct aiocb *aiocbp
 1649                 );
 1650         }
 1651 318     AUE_AIO_READ    COMPAT6 {
 1652                 int aio_read(
 1653                     _Inout_  struct oaiocb *aiocbp
 1654                 );
 1655         }
 1656 319     AUE_AIO_WRITE   COMPAT6 {
 1657                 int aio_write(
 1658                     _Inout_ struct oaiocb *aiocbp
 1659                 );
 1660         }
 1661 320     AUE_LIO_LISTIO  COMPAT6 {
 1662                 int lio_listio(
 1663                     int mode,
 1664                     _Inout_updates_(nent) struct oaiocb * const *acb_list,
 1665                     int nent,
 1666                     _In_opt_ struct osigevent *sig
 1667                 );
 1668         }
 1669 321     AUE_NULL        STD {
 1670                 int yield(void);
 1671         }
 1672 322     AUE_NULL        OBSOL   thr_sleep
 1673 323     AUE_NULL        OBSOL   thr_wakeup
 1674 324     AUE_MLOCKALL    STD {
 1675                 int mlockall(
 1676                     int how
 1677                 );
 1678         }
 1679 325     AUE_MUNLOCKALL  STD {
 1680                 int munlockall(void); }
 1681 326     AUE_GETCWD      STD {
 1682                 int __getcwd(
 1683                     _Out_writes_z_(buflen) char *buf,
 1684                     size_t buflen
 1685                 );
 1686         }
 1687 327     AUE_NULL        STD {
 1688                 int sched_setparam(
 1689                     pid_t pid,
 1690                     _In_ const struct sched_param *param
 1691                 );
 1692         }
 1693 328     AUE_NULL        STD {
 1694                 int sched_getparam(
 1695                     pid_t pid,
 1696                     _Out_ struct sched_param *param
 1697                 );
 1698         }
 1699 329     AUE_NULL        STD {
 1700                 int sched_setscheduler(
 1701                     pid_t pid,
 1702                     int policy,
 1703                     _In_ const struct sched_param *param
 1704                 );
 1705         }
 1706 330     AUE_NULL        STD {
 1707                 int sched_getscheduler(
 1708                     pid_t pid
 1709                 );
 1710         }
 1711 331     AUE_NULL        STD {
 1712                 int sched_yield(void);
 1713         }
 1714 332     AUE_NULL        STD {
 1715                 int sched_get_priority_max(
 1716                     int policy
 1717                 );
 1718         }
 1719 333     AUE_NULL        STD {
 1720                 int sched_get_priority_min(
 1721                     int policy
 1722                 );
 1723         }
 1724 334     AUE_NULL        STD {
 1725                 int sched_rr_get_interval(
 1726                     pid_t pid,
 1727                     _Out_ struct timespec *interval
 1728                 );
 1729         }
 1730 335     AUE_NULL        STD {
 1731                 int utrace(
 1732                    _In_reads_bytes_(len) const void *addr,
 1733                     size_t len
 1734                 );
 1735         }
 1736 336     AUE_SENDFILE    COMPAT4 {
 1737                 int sendfile(
 1738                     int fd,
 1739                     int s,
 1740                     off_t offset,
 1741                     size_t nbytes,
 1742                     _In_opt_ struct sf_hdtr *hdtr,
 1743                     _Out_opt_ off_t *sbytes,
 1744                     int flags
 1745                 );
 1746         }
 1747 337     AUE_NULL        STD {
 1748                 int kldsym(
 1749                     int fileid,
 1750                     int cmd,
 1751                     _In_ void *data
 1752                 );
 1753         }
 1754 338     AUE_JAIL        STD {
 1755                 int jail(
 1756                     _In_ struct jail *jail
 1757                 );
 1758         }
 1759 339     AUE_NULL        NOSTD|NOTSTATIC {
 1760                 int nnpfs_syscall(
 1761                     int operation,
 1762                     char *a_pathP,
 1763                     int a_opcode,
 1764                     void *a_paramsP,
 1765                     int a_followSymlinks
 1766                 );
 1767         }
 1768 340     AUE_SIGPROCMASK STD {
 1769                 int sigprocmask(
 1770                     int how,
 1771                     _In_opt_ const sigset_t *set,
 1772                     _Out_opt_ sigset_t *oset
 1773                 );
 1774         }
 1775 341     AUE_SIGSUSPEND  STD {
 1776                 int sigsuspend(
 1777                     _In_ const sigset_t *sigmask
 1778                 );
 1779         }
 1780 342     AUE_SIGACTION   COMPAT4 {
 1781                 int sigaction(
 1782                     int sig,
 1783                     _In_opt_ const struct sigaction *act,
 1784                     _Out_opt_ struct sigaction *oact
 1785                 );
 1786         }
 1787 343     AUE_SIGPENDING  STD {
 1788                 int sigpending(
 1789                     _In_ sigset_t *set
 1790                 );
 1791         }
 1792 344     AUE_SIGRETURN   COMPAT4 {
 1793                 int sigreturn(
 1794                     _In_ const struct ucontext4 *sigcntxp
 1795                 );
 1796         }
 1797 345     AUE_SIGWAIT     STD {
 1798                 int sigtimedwait(
 1799                     _In_ const sigset_t *set,
 1800                     _Out_opt_ siginfo_t *info,
 1801                     _In_opt_ const struct timespec *timeout
 1802                 );
 1803         }
 1804 346     AUE_NULL        STD {
 1805                 int sigwaitinfo(
 1806                     _In_ const sigset_t *set,
 1807                     _Out_opt_ siginfo_t *info
 1808                 );
 1809         }
 1810 347     AUE_ACL_GET_FILE        STD {
 1811                 int __acl_get_file(
 1812                     _In_z_ const char *path,
 1813                     acl_type_t type,
 1814                     _Out_ struct acl *aclp
 1815                 );
 1816         }
 1817 348     AUE_ACL_SET_FILE        STD {
 1818                 int __acl_set_file(
 1819                     _In_z_ const char *path,
 1820                     acl_type_t type,
 1821                     _In_ struct acl *aclp
 1822                 );
 1823         }
 1824 349     AUE_ACL_GET_FD  STD {
 1825                 int __acl_get_fd(
 1826                     int filedes,
 1827                     acl_type_t type,
 1828                     _Out_ struct acl *aclp
 1829                 );
 1830         }
 1831 350     AUE_ACL_SET_FD  STD {
 1832                 int __acl_set_fd(
 1833                     int filedes,
 1834                     acl_type_t type,
 1835                     _In_ struct acl *aclp
 1836                 );
 1837         }
 1838 351     AUE_ACL_DELETE_FILE     STD {
 1839                 int __acl_delete_file(
 1840                     _In_z_ const char *path,
 1841                     acl_type_t type
 1842                 );
 1843         }
 1844 352     AUE_ACL_DELETE_FD       STD {
 1845                 int __acl_delete_fd(
 1846                     int filedes,
 1847                     acl_type_t type
 1848                 );
 1849         }
 1850 353     AUE_ACL_CHECK_FILE      STD {
 1851                 int __acl_aclcheck_file(
 1852                     _In_z_ const char *path,
 1853                     acl_type_t type,
 1854                     _In_ struct acl *aclp
 1855                 );
 1856         }
 1857 354     AUE_ACL_CHECK_FD        STD {
 1858                 int __acl_aclcheck_fd(
 1859                     int filedes,
 1860                     acl_type_t type,
 1861                     _In_ struct acl *aclp
 1862                 );
 1863         }
 1864 355     AUE_EXTATTRCTL  STD {
 1865                 int extattrctl(
 1866                     _In_z_ const char *path,
 1867                     int cmd,
 1868                     _In_z_opt_ const char *filename,
 1869                     int attrnamespace,
 1870                     _In_z_ const char *attrname
 1871                 );
 1872         }
 1873 356     AUE_EXTATTR_SET_FILE    STD {
 1874                 ssize_t extattr_set_file(
 1875                     _In_z_ const char *path,
 1876                     int attrnamespace,
 1877                     _In_z_ const char *attrname,
 1878                     _In_reads_bytes_(nbytes) void *data,
 1879                     size_t nbytes
 1880                 );
 1881         }
 1882 357     AUE_EXTATTR_GET_FILE    STD {
 1883                 ssize_t extattr_get_file(
 1884                     _In_z_ const char *path,
 1885                     int attrnamespace,
 1886                     _In_z_ const char *attrname,
 1887                     _Out_writes_bytes_(nbytes) void *data,
 1888                     size_t nbytes
 1889                 );
 1890         }
 1891 358     AUE_EXTATTR_DELETE_FILE STD {
 1892                 int extattr_delete_file(
 1893                     _In_z_ const char *path,
 1894                     int attrnamespace,
 1895                     _In_z_ const char *attrname
 1896                 );
 1897         }
 1898 359     AUE_AIO_WAITCOMPLETE    STD {
 1899                 ssize_t aio_waitcomplete(
 1900                     _Outptr_result_maybenull_ struct aiocb **aiocbp,
 1901                     _In_opt_ struct timespec *timeout
 1902                 );
 1903         }
 1904 360     AUE_GETRESUID   STD {
 1905                 int getresuid(
 1906                     _Out_opt_ uid_t *ruid,
 1907                     _Out_opt_ uid_t *euid,
 1908                     _Out_opt_ uid_t *suid
 1909                 );
 1910         }
 1911 361     AUE_GETRESGID   STD {
 1912                 int getresgid(
 1913                     _Out_opt_ gid_t *rgid,
 1914                     _Out_opt_ gid_t *egid,
 1915                     _Out_opt_ gid_t *sgid
 1916                 );
 1917         }
 1918 362     AUE_KQUEUE      STD {
 1919                 int kqueue(void);
 1920         }
 1921 363     AUE_KEVENT      COMPAT11 {
 1922                 int kevent(
 1923                     int fd,
 1924                     _In_reads_opt_(nchanges) struct kevent_freebsd11 *changelist,
 1925                     int nchanges,
 1926                     _Out_writes_opt_(nevents) struct kevent_freebsd11 *eventlist,
 1927                     int nevents,
 1928                     _In_opt_ const struct timespec *timeout
 1929                 );
 1930         }
 1931 364     AUE_NULL        OBSOL   __cap_get_proc
 1932 365     AUE_NULL        OBSOL   __cap_set_proc
 1933 366     AUE_NULL        OBSOL   __cap_get_fd
 1934 367     AUE_NULL        OBSOL   __cap_get_file
 1935 368     AUE_NULL        OBSOL   __cap_set_fd
 1936 369     AUE_NULL        OBSOL   __cap_set_file
 1937 370     AUE_NULL        UNIMPL  nosys
 1938 371     AUE_EXTATTR_SET_FD      STD {
 1939                 ssize_t extattr_set_fd(
 1940                     int fd,
 1941                     int attrnamespace,
 1942                     _In_z_ const char *attrname,
 1943                     _In_reads_bytes_(nbytes) void *data,
 1944                     size_t nbytes
 1945                 );
 1946         }
 1947 372     AUE_EXTATTR_GET_FD      STD {
 1948                 ssize_t extattr_get_fd(
 1949                     int fd,
 1950                     int attrnamespace,
 1951                     _In_z_ const char *attrname,
 1952                     _Out_writes_bytes_(nbytes) void *data,
 1953                     size_t nbytes
 1954                 );
 1955         }
 1956 373     AUE_EXTATTR_DELETE_FD   STD {
 1957                 int extattr_delete_fd(
 1958                     int fd,
 1959                     int attrnamespace,
 1960                     _In_z_ const char *attrname
 1961                 );
 1962         }
 1963 374     AUE_SETUGID     STD {
 1964                 int __setugid(
 1965                     int flag
 1966                 );
 1967         }
 1968 375     AUE_NULL        OBSOL   nfsclnt
 1969 376     AUE_EACCESS     STD {
 1970                 int eaccess(
 1971                     _In_z_ const char *path,
 1972                     int amode
 1973                 );
 1974         }
 1975 377     AUE_NULL        NOSTD|NOTSTATIC {
 1976                 int afs3_syscall(
 1977                     long syscall,
 1978                     long parm1,
 1979                     long parm2,
 1980                     long parm3,
 1981                     long parm4,
 1982                     long parm5,
 1983                     long parm6
 1984                 );
 1985         }
 1986 378     AUE_NMOUNT      STD {
 1987                 int nmount(
 1988                     _In_reads_(iovcnt) struct iovec *iovp,
 1989                     unsigned int iovcnt,
 1990                     int flags
 1991                 );
 1992         }
 1993 379     AUE_NULL        OBSOL   kse_exit
 1994 380     AUE_NULL        OBSOL   kse_wakeup
 1995 381     AUE_NULL        OBSOL   kse_create
 1996 382     AUE_NULL        OBSOL   kse_thr_interrupt
 1997 383     AUE_NULL        OBSOL   kse_release
 1998 384     AUE_NULL        STD {
 1999                 int __mac_get_proc(
 2000                     _In_ struct mac *mac_p
 2001                 );
 2002         }
 2003 385     AUE_NULL        STD {
 2004                 int __mac_set_proc(
 2005                     _In_ struct mac *mac_p
 2006                 );
 2007         }
 2008 386     AUE_NULL        STD {
 2009                 int __mac_get_fd(
 2010                     int fd,
 2011                     _In_ struct mac *mac_p
 2012                 );
 2013         }
 2014 387     AUE_NULL        STD {
 2015                 int __mac_get_file(
 2016                     _In_z_ const char *path_p,
 2017                     _In_ struct mac *mac_p
 2018                 );
 2019         }
 2020 388     AUE_NULL        STD {
 2021                 int __mac_set_fd(
 2022                     int fd,
 2023                     _In_ struct mac *mac_p
 2024                 );
 2025         }
 2026 389     AUE_NULL        STD {
 2027                 int __mac_set_file(
 2028                     _In_z_ const char *path_p,
 2029                     _In_ struct mac *mac_p
 2030                 );
 2031         }
 2032 390     AUE_NULL        STD {
 2033                 int kenv(
 2034                     int what,
 2035                     _In_z_opt_ const char *name,
 2036                     _Inout_updates_opt_(len) char *value,
 2037                     int len
 2038                 );
 2039         }
 2040 391     AUE_LCHFLAGS    STD {
 2041                 int lchflags(
 2042                     _In_z_ const char *path,
 2043                     u_long flags
 2044                 );
 2045         }
 2046 392     AUE_NULL        STD {
 2047                 int uuidgen(
 2048                     _Out_writes_(count) struct uuid *store,
 2049                     int count
 2050                 );
 2051         }
 2052 393     AUE_SENDFILE    STD {
 2053                 int sendfile(
 2054                     int fd,
 2055                     int s,
 2056                     off_t offset,
 2057                     size_t nbytes,
 2058                     _In_opt_ struct sf_hdtr *hdtr,
 2059                     _Out_opt_ off_t *sbytes,
 2060                     int flags
 2061                 );
 2062         }
 2063 394     AUE_NULL        STD {
 2064                 int mac_syscall(
 2065                     _In_z_ const char *policy,
 2066                     int call,
 2067                     _In_opt_ void *arg
 2068                 );
 2069         }
 2070 395     AUE_GETFSSTAT   COMPAT11 {
 2071                 int getfsstat(
 2072                     _Out_writes_bytes_opt_(bufsize) struct freebsd11_statfs *buf,
 2073                     long bufsize,
 2074                     int mode
 2075                 );
 2076         }
 2077 396     AUE_STATFS      COMPAT11 {
 2078                 int statfs(
 2079                     _In_z_ const char *path,
 2080                     _Out_ struct freebsd11_statfs *buf
 2081                 );
 2082         }
 2083 397     AUE_FSTATFS     COMPAT11 {
 2084                 int fstatfs(
 2085                     int fd,
 2086                     _Out_ struct freebsd11_statfs *buf
 2087                 );
 2088         }
 2089 398     AUE_FHSTATFS    COMPAT11 {
 2090                 int fhstatfs(
 2091                     _In_ const struct fhandle *u_fhp,
 2092                     _Out_ struct freebsd11_statfs *buf
 2093                 );
 2094         }
 2095 399     AUE_NULL        UNIMPL  nosys
 2096 400     AUE_SEMCLOSE    NOSTD {
 2097                 int ksem_close(
 2098                     semid_t id
 2099                 );
 2100         }
 2101 401     AUE_SEMPOST     NOSTD {
 2102                 int ksem_post(
 2103                     semid_t id
 2104                 );
 2105         }
 2106 402     AUE_SEMWAIT     NOSTD {
 2107                 int ksem_wait(
 2108                     semid_t id
 2109                 );
 2110         }
 2111 403     AUE_SEMTRYWAIT  NOSTD {
 2112                 int ksem_trywait(
 2113                     semid_t id
 2114                 );
 2115         }
 2116 404     AUE_SEMINIT     NOSTD {
 2117                 int ksem_init(
 2118                     _Out_ semid_t *idp,
 2119                     unsigned int value
 2120                 );
 2121         }
 2122 405     AUE_SEMOPEN     NOSTD {
 2123                 int ksem_open(
 2124                     _Out_ semid_t *idp,
 2125                     _In_z_ const char *name,
 2126                     int oflag,
 2127                     mode_t mode,
 2128                     unsigned int value
 2129                 );
 2130         }
 2131 406     AUE_SEMUNLINK   NOSTD {
 2132                 int ksem_unlink(
 2133                     _In_z_ const char *name
 2134                 );
 2135         }
 2136 407     AUE_SEMGETVALUE NOSTD {
 2137                 int ksem_getvalue(
 2138                     semid_t id,
 2139                     _Out_ int *val
 2140                 );
 2141         }
 2142 408     AUE_SEMDESTROY  NOSTD {
 2143                 int ksem_destroy(
 2144                     semid_t id
 2145                 );
 2146         }
 2147 409     AUE_NULL        STD {
 2148                 int __mac_get_pid(
 2149                     pid_t pid,
 2150                     _In_ struct mac *mac_p
 2151                 );
 2152         }
 2153 410     AUE_NULL        STD {
 2154                 int __mac_get_link(
 2155                     _In_z_ const char *path_p,
 2156                     _In_ struct mac *mac_p
 2157                 );
 2158         }
 2159 411     AUE_NULL        STD {
 2160                 int __mac_set_link(
 2161                     _In_z_ const char *path_p,
 2162                     _In_ struct mac *mac_p
 2163                 );
 2164         }
 2165 412     AUE_EXTATTR_SET_LINK    STD {
 2166                 ssize_t extattr_set_link(
 2167                     _In_z_ const char *path,
 2168                     int attrnamespace,
 2169                     _In_z_ const char *attrname,
 2170                     _In_reads_bytes_(nbytes) void *data,
 2171                     size_t nbytes
 2172                 );
 2173         }
 2174 413     AUE_EXTATTR_GET_LINK    STD {
 2175                 ssize_t extattr_get_link(
 2176                     _In_z_ const char *path,
 2177                     int attrnamespace,
 2178                     _In_z_ const char *attrname,
 2179                     _Out_writes_bytes_(nbytes) void *data,
 2180                     size_t nbytes
 2181                 );
 2182         }
 2183 414     AUE_EXTATTR_DELETE_LINK STD {
 2184                 int extattr_delete_link(
 2185                     _In_z_ const char *path,
 2186                     int attrnamespace,
 2187                     _In_z_ const char *attrname
 2188                 );
 2189         }
 2190 415     AUE_NULL        STD {
 2191                 int __mac_execve(
 2192                     _In_z_ const char *fname,
 2193                     _In_ char **argv,
 2194                     _In_ char **envv,
 2195                     _In_ struct mac *mac_p
 2196                 );
 2197         }
 2198 416     AUE_SIGACTION   STD {
 2199                 int sigaction(
 2200                     int sig,
 2201                     _In_opt_ const struct sigaction *act,
 2202                     _Out_opt_ struct sigaction *oact
 2203                 );
 2204         }
 2205 417     AUE_SIGRETURN   STD {
 2206                 int sigreturn(
 2207                     _In_ const struct __ucontext *sigcntxp
 2208                 );
 2209         }
 2210 418     AUE_NULL        UNIMPL  __xstat
 2211 419     AUE_NULL        UNIMPL  __xfstat
 2212 420     AUE_NULL        UNIMPL  __xlstat
 2213 421     AUE_NULL        STD {
 2214                 int getcontext(
 2215                     _Out_ struct __ucontext *ucp
 2216                 );
 2217         }
 2218 422     AUE_NULL        STD {
 2219                 int setcontext(
 2220                     _In_ const struct __ucontext *ucp
 2221                 );
 2222         }
 2223 423     AUE_NULL        STD {
 2224                 int swapcontext(
 2225                     _Out_ struct __ucontext *oucp,
 2226                     _In_ const struct __ucontext *ucp
 2227                 );
 2228         }
 2229 424     AUE_SWAPOFF     STD {
 2230                 int swapoff(
 2231                     _In_z_ const char *name
 2232                 );
 2233         }
 2234 425     AUE_ACL_GET_LINK        STD {
 2235                 int __acl_get_link(
 2236                     _In_z_ const char *path,
 2237                     acl_type_t type,
 2238                     _Out_ struct acl *aclp
 2239                 );
 2240         }
 2241 426     AUE_ACL_SET_LINK        STD {
 2242                 int __acl_set_link(
 2243                     _In_z_ const char *path,
 2244                     acl_type_t type,
 2245                     _In_ struct acl *aclp
 2246                 );
 2247         }
 2248 427     AUE_ACL_DELETE_LINK     STD {
 2249                 int __acl_delete_link(
 2250                     _In_z_ const char *path,
 2251                     acl_type_t type
 2252                 );
 2253         }
 2254 428     AUE_ACL_CHECK_LINK      STD {
 2255                 int __acl_aclcheck_link(
 2256                     _In_z_ const char *path,
 2257                     acl_type_t type,
 2258                     _In_ struct acl *aclp
 2259                 );
 2260         }
 2261 429     AUE_SIGWAIT     STD {
 2262                 int sigwait(
 2263                     _In_ const sigset_t *set,
 2264                     _Out_ int *sig
 2265                 );
 2266         }
 2267 430     AUE_THR_CREATE  STD {
 2268                 int thr_create(
 2269                     _In_ ucontext_t *ctx,
 2270                     _Out_ long *id,
 2271                     int flags
 2272                 );
 2273         }
 2274 431     AUE_THR_EXIT    STD {
 2275                 void thr_exit(
 2276                     _Out_opt_ long *state
 2277                 );
 2278         }
 2279 432     AUE_NULL        STD {
 2280                 int thr_self(
 2281                     _Out_ long *id
 2282                 );
 2283         }
 2284 433     AUE_THR_KILL    STD {
 2285                 int thr_kill(
 2286                     long id,
 2287                     int sig
 2288                 );
 2289         }
 2290 434-435 AUE_NULL        UNIMPL  nosys
 2291 436     AUE_JAIL_ATTACH STD {
 2292                 int jail_attach(
 2293                     int jid
 2294                 );
 2295         }
 2296 437     AUE_EXTATTR_LIST_FD     STD {
 2297                 ssize_t extattr_list_fd(
 2298                     int fd,
 2299                     int attrnamespace,
 2300                     _Out_writes_bytes_opt_(nbytes) void *data,
 2301                     size_t nbytes
 2302                 );
 2303         }
 2304 438     AUE_EXTATTR_LIST_FILE   STD {
 2305                 ssize_t extattr_list_file(
 2306                     _In_z_ const char *path,
 2307                     int attrnamespace,
 2308                     _Out_writes_bytes_opt_(nbytes) void *data,
 2309                     size_t nbytes
 2310                 );
 2311         }
 2312 439     AUE_EXTATTR_LIST_LINK   STD {
 2313                 ssize_t extattr_list_link(
 2314                     _In_z_ const char *path,
 2315                     int attrnamespace,
 2316                     _Out_writes_bytes_opt_(nbytes)
 2317                     void *data,
 2318                     size_t nbytes
 2319                 );
 2320         }
 2321 440     AUE_NULL        OBSOL   kse_switchin
 2322 441     AUE_SEMWAIT     NOSTD {
 2323                 int ksem_timedwait(
 2324                     semid_t id,
 2325                     _In_opt_ const struct timespec *abstime
 2326                 );
 2327         }
 2328 442     AUE_NULL        STD {
 2329                 int thr_suspend(
 2330                     _In_opt_ const struct timespec *timeout
 2331                 );
 2332         }
 2333 443     AUE_NULL        STD {
 2334                 int thr_wake(
 2335                     long id
 2336                 );
 2337         }
 2338 444     AUE_MODUNLOAD   STD {
 2339                 int kldunloadf(
 2340                     int fileid,
 2341                     int flags
 2342                 );
 2343         }
 2344 445     AUE_AUDIT       STD {
 2345                 int audit(
 2346                     _In_reads_bytes_(length) const void *record,
 2347                     u_int length
 2348                 );
 2349         }
 2350 446     AUE_AUDITON     STD {
 2351                 int auditon(
 2352                     int cmd,
 2353                     _In_opt_ void *data,
 2354                     u_int length
 2355                 );
 2356         }
 2357 447     AUE_GETAUID     STD {
 2358                 int getauid(
 2359                     _Out_ uid_t *auid
 2360                 );
 2361         }
 2362 448     AUE_SETAUID     STD {
 2363                 int setauid(
 2364                     _In_ uid_t *auid
 2365                 );
 2366         }
 2367 449     AUE_GETAUDIT    STD {
 2368                 int getaudit(
 2369                     _Out_ struct auditinfo *auditinfo
 2370                 );
 2371         }
 2372 450     AUE_SETAUDIT    STD {
 2373                 int setaudit(
 2374                     _In_ struct auditinfo *auditinfo
 2375                 );
 2376         }
 2377 451     AUE_GETAUDIT_ADDR       STD {
 2378                 int getaudit_addr(
 2379                     _Out_writes_bytes_(length) struct auditinfo_addr *auditinfo_addr,
 2380                     u_int length
 2381                 );
 2382         }
 2383 452     AUE_SETAUDIT_ADDR       STD {
 2384                 int setaudit_addr(
 2385                     _In_reads_bytes_(length) struct auditinfo_addr *auditinfo_addr,
 2386                     u_int length
 2387                 );
 2388         }
 2389 453     AUE_AUDITCTL    STD {
 2390                 int auditctl(
 2391                     _In_z_ const char *path
 2392                 );
 2393         }
 2394 454     AUE_NULL        STD {
 2395                 int _umtx_op(
 2396                     _Inout_ void *obj,
 2397                     int op,
 2398                     u_long val,
 2399                     _In_ void *uaddr1,
 2400                     _In_ void *uaddr2
 2401                 );
 2402         }
 2403 455     AUE_THR_NEW     STD {
 2404                 int thr_new(
 2405                     _In_ struct thr_param *param,
 2406                     int param_size
 2407                 );
 2408         }
 2409 456     AUE_NULL        STD {
 2410                 int sigqueue(
 2411                     pid_t pid,
 2412                     int signum,
 2413                     _In_ void *value
 2414                 );
 2415         }
 2416 
 2417 457     AUE_MQ_OPEN     NOSTD {
 2418                 int kmq_open(
 2419                     _In_z_ const char *path,
 2420                     int flags,
 2421                     mode_t mode,
 2422                     _In_opt_ const struct mq_attr *attr
 2423                 );
 2424         }
 2425 458     AUE_MQ_SETATTR  NOSTD {
 2426                 int kmq_setattr(
 2427                     int mqd,
 2428                     _In_opt_ const struct mq_attr *attr,
 2429                     _Out_opt_ struct mq_attr *oattr
 2430                 );
 2431         }
 2432 459     AUE_MQ_TIMEDRECEIVE     NOSTD {
 2433                 int kmq_timedreceive(
 2434                     int mqd,
 2435                     _Out_writes_bytes_(msg_len) char *msg_ptr,
 2436                     size_t msg_len,
 2437                     _Out_opt_ unsigned *msg_prio,
 2438                     _In_opt_ const struct timespec *abs_timeout
 2439                 );
 2440         }
 2441 460     AUE_MQ_TIMEDSEND        NOSTD {
 2442                 int kmq_timedsend(
 2443                     int mqd,
 2444                     _In_reads_bytes_(msg_len) const char *msg_ptr,
 2445                     size_t msg_len,
 2446                     unsigned msg_prio,
 2447                     _In_opt_ const struct timespec *abs_timeout
 2448                 );
 2449         }
 2450 461     AUE_MQ_NOTIFY   NOSTD {
 2451                 int kmq_notify(
 2452                     int mqd,
 2453                     _In_opt_ const struct sigevent *sigev
 2454                 );
 2455         }
 2456 462     AUE_MQ_UNLINK   NOSTD {
 2457                 int kmq_unlink(
 2458                     _In_z_ const char *path
 2459                 );
 2460         }
 2461 463     AUE_NULL        STD {
 2462                 int abort2(
 2463                     _In_z_ const char *why,
 2464                     int nargs,
 2465                     _In_reads_(nargs) void **args
 2466                 );
 2467         }
 2468 464     AUE_NULL        STD {
 2469                 int thr_set_name(
 2470                     long id,
 2471                     _In_z_ const char *name
 2472                 );
 2473         }
 2474 465     AUE_AIO_FSYNC   STD {
 2475                 int aio_fsync(
 2476                     int op,
 2477                     _In_ struct aiocb *aiocbp
 2478                 );
 2479         }
 2480 466     AUE_RTPRIO      STD {
 2481                 int rtprio_thread(
 2482                     int function,
 2483                     lwpid_t lwpid,
 2484                     _Inout_ struct rtprio *rtp
 2485                 );
 2486         }
 2487 467-468 AUE_NULL        UNIMPL  nosys
 2488 469     AUE_NULL        UNIMPL  __getpath_fromfd
 2489 470     AUE_NULL        UNIMPL  __getpath_fromaddr
 2490 471     AUE_SCTP_PEELOFF        NOSTD {
 2491                 int sctp_peeloff(
 2492                     int sd,
 2493                     uint32_t name
 2494                 );
 2495         }
 2496 472     AUE_SCTP_GENERIC_SENDMSG        NOSTD {
 2497                 int sctp_generic_sendmsg(
 2498                     int sd,
 2499                     _In_reads_bytes_(mlen) void *msg,
 2500                     int mlen,
 2501                     _In_reads_bytes_(tolen) struct sockaddr *to,
 2502                     __socklen_t tolen,
 2503                     _In_opt_ struct sctp_sndrcvinfo *sinfo,
 2504                     int flags
 2505                 );
 2506         }
 2507 473     AUE_SCTP_GENERIC_SENDMSG_IOV    NOSTD {
 2508                 int sctp_generic_sendmsg_iov(
 2509                     int sd,
 2510                     _In_reads_(iovlen) struct iovec *iov,
 2511                     int iovlen,
 2512                     _In_reads_bytes_(tolen) struct sockaddr *to,
 2513                     __socklen_t tolen,
 2514                     _In_opt_ struct sctp_sndrcvinfo *sinfo,
 2515                     int flags
 2516                 );
 2517         }
 2518 474     AUE_SCTP_GENERIC_RECVMSG        NOSTD {
 2519                 int sctp_generic_recvmsg(
 2520                     int sd,
 2521                     _In_reads_(iovlen) struct iovec *iov,
 2522                     int iovlen,
 2523                     _Out_writes_bytes_(*fromlenaddr) struct sockaddr *from,
 2524                     _Out_ __socklen_t *fromlenaddr,
 2525                     _In_opt_ struct sctp_sndrcvinfo *sinfo,
 2526                     _Out_opt_ int *msg_flags
 2527                 );
 2528         }
 2529 475     AUE_PREAD       STD {
 2530                 ssize_t pread(
 2531                     int fd,
 2532                     _Out_writes_bytes_(nbyte) void *buf,
 2533                     size_t nbyte,
 2534                     off_t offset
 2535                 );
 2536         }
 2537 476     AUE_PWRITE      STD {
 2538                 ssize_t pwrite(
 2539                     int fd,
 2540                     _In_reads_bytes_(nbyte) const void *buf,
 2541                     size_t nbyte,
 2542                     off_t offset
 2543                 );
 2544         }
 2545 477     AUE_MMAP        STD {
 2546                 void *mmap(
 2547                     _In_ void *addr,
 2548                     size_t len,
 2549                     int prot,
 2550                     int flags,
 2551                     int fd,
 2552                     off_t pos
 2553                 );
 2554         }
 2555 478     AUE_LSEEK       STD {
 2556                 off_t lseek(
 2557                     int fd,
 2558                     off_t offset,
 2559                     int whence
 2560                 );
 2561         }
 2562 479     AUE_TRUNCATE    STD {
 2563                 int truncate(
 2564                     _In_z_ const char *path,
 2565                     off_t length
 2566                 );
 2567         }
 2568 480     AUE_FTRUNCATE   STD {
 2569                 int ftruncate(
 2570                     int fd,
 2571                     off_t length
 2572                 );
 2573         }
 2574 481     AUE_THR_KILL2   STD {
 2575                 int thr_kill2(
 2576                     pid_t pid,
 2577                     long id,
 2578                     int sig
 2579                 );
 2580         }
 2581 482     AUE_SHMOPEN     STD {
 2582                 int shm_open(
 2583                     _In_z_ const char *path,
 2584                     int flags,
 2585                     mode_t mode
 2586                 );
 2587         }
 2588 483     AUE_SHMUNLINK   STD {
 2589                 int shm_unlink(
 2590                     _In_z_ const char *path
 2591                 );
 2592         }
 2593 484     AUE_NULL        STD {
 2594                 int cpuset(
 2595                     _Out_ cpusetid_t *setid
 2596                 );
 2597         }
 2598 485     AUE_NULL        STD {
 2599                 int cpuset_setid(
 2600                     cpuwhich_t which,
 2601                     id_t id,
 2602                     cpusetid_t setid
 2603                 );
 2604         }
 2605 486     AUE_NULL        STD {
 2606                 int cpuset_getid(
 2607                     cpulevel_t level,
 2608                     cpuwhich_t which,
 2609                     id_t id,
 2610                     _Out_ cpusetid_t *setid
 2611                 );
 2612         }
 2613 487     AUE_NULL        STD {
 2614                 int cpuset_getaffinity(
 2615                     cpulevel_t level,
 2616                     cpuwhich_t which,
 2617                     id_t id,
 2618                     size_t cpusetsize,
 2619                     _Out_ cpuset_t *mask
 2620                 );
 2621         }
 2622 488     AUE_NULL        STD {
 2623                 int cpuset_setaffinity(
 2624                     cpulevel_t level,
 2625                     cpuwhich_t which,
 2626                     id_t id,
 2627                     size_t cpusetsize,
 2628                     _Out_ const cpuset_t *mask
 2629                 );
 2630         }
 2631 489     AUE_FACCESSAT   STD {
 2632                 int faccessat(
 2633                     int fd,
 2634                     _In_z_ const char *path,
 2635                     int amode,
 2636                     int flag
 2637                 );
 2638         }
 2639 490     AUE_FCHMODAT    STD {
 2640                 int fchmodat(
 2641                     int fd,
 2642                     _In_z_ const char *path,
 2643                     mode_t mode,
 2644                     int flag
 2645                 );
 2646         }
 2647 491     AUE_FCHOWNAT    STD {
 2648                 int fchownat(
 2649                     int fd,
 2650                     _In_z_ const char *path,
 2651                     uid_t uid,
 2652                     gid_t gid,
 2653                     int flag
 2654                 );
 2655         }
 2656 492     AUE_FEXECVE     STD {
 2657                 int fexecve(
 2658                     int fd,
 2659                     _In_ char **argv,
 2660                     _In_ char **envv
 2661                 );
 2662         }
 2663 493     AUE_FSTATAT     COMPAT11 {
 2664                 int fstatat(
 2665                     int fd,
 2666                     _In_z_ const char *path,
 2667                     _Out_ struct freebsd11_stat *buf,
 2668                     int flag
 2669                 );
 2670         }
 2671 494     AUE_FUTIMESAT   STD {
 2672                 int futimesat(
 2673                     int fd,
 2674                     _In_z_ const char *path,
 2675                     _In_reads_(2) struct timeval *times
 2676                 );
 2677         }
 2678 495     AUE_LINKAT      STD {
 2679                 int linkat(
 2680                     int fd1,
 2681                     _In_z_ const char *path1,
 2682                     int fd2,
 2683                     _In_z_ const char *path2,
 2684                     int flag
 2685                 );
 2686         }
 2687 496     AUE_MKDIRAT     STD {
 2688                 int mkdirat(
 2689                     int fd,
 2690                     _In_z_ const char *path,
 2691                     mode_t mode
 2692                 );
 2693         }
 2694 497     AUE_MKFIFOAT    STD {
 2695                 int mkfifoat(
 2696                     int fd,
 2697                     _In_z_ const char *path,
 2698                     mode_t mode
 2699                 );
 2700         }
 2701 498     AUE_MKNODAT     COMPAT11 {
 2702                 int mknodat(
 2703                     int fd,
 2704                     _In_z_ const char *path,
 2705                     mode_t mode,
 2706                     uint32_t dev
 2707                 );
 2708         }
 2709 ; XXX: see the comment for open
 2710 499     AUE_OPENAT_RWTC STD {
 2711                 int openat(
 2712                     int fd,
 2713                     _In_z_ const char *path,
 2714                     int flag,
 2715                     mode_t mode
 2716                 );
 2717         }
 2718 500     AUE_READLINKAT  STD {
 2719                 int readlinkat(
 2720                     int fd,
 2721                     _In_z_ const char *path,
 2722                     _Out_writes_bytes_(bufsize) char *buf,
 2723                     size_t bufsize
 2724                 );
 2725         }
 2726 501     AUE_RENAMEAT    STD {
 2727                 int renameat(
 2728                     int oldfd,
 2729                     _In_z_ const char *old,
 2730                     int newfd,
 2731                     _In_z_ const char *new
 2732                 );
 2733         }
 2734 502     AUE_SYMLINKAT   STD {
 2735                 int symlinkat(
 2736                     _In_z_ const char *path1,
 2737                     int fd,
 2738                     _In_z_ const char *path2
 2739                 );
 2740         }
 2741 503     AUE_UNLINKAT    STD {
 2742                 int unlinkat(
 2743                     int fd,
 2744                     _In_z_ const char *path,
 2745                     int flag
 2746                 );
 2747         }
 2748 504     AUE_POSIX_OPENPT        STD {
 2749                 int posix_openpt(
 2750                     int flags
 2751                 );
 2752         }
 2753 ; 505 is initialised by the kgssapi code, if present.
 2754 505     AUE_NULL        NOSTD {
 2755                 int gssd_syscall(
 2756                     _In_z_ const char *path
 2757                 );
 2758         }
 2759 506     AUE_JAIL_GET    STD {
 2760                 int jail_get(
 2761                     _In_reads_(iovcnt) struct iovec *iovp,
 2762                     unsigned int iovcnt,
 2763                     int flags
 2764                 );
 2765         }
 2766 507     AUE_JAIL_SET    STD {
 2767                 int jail_set(
 2768                     _In_reads_(iovcnt) struct iovec *iovp,
 2769                     unsigned int iovcnt,
 2770                     int flags
 2771                 );
 2772         }
 2773 508     AUE_JAIL_REMOVE STD {
 2774                 int jail_remove(
 2775                     int jid
 2776                 );
 2777         }
 2778 509     AUE_CLOSEFROM   STD {
 2779                 int closefrom(
 2780                     int lowfd
 2781                 );
 2782         }
 2783 510     AUE_SEMCTL      NOSTD {
 2784                 int __semctl(
 2785                     int semid,
 2786                     int semnum,
 2787                     int cmd,
 2788                     _Inout_ union semun *arg
 2789                 );
 2790         }
 2791 511     AUE_MSGCTL      NOSTD {
 2792                 int msgctl(
 2793                     int msqid,
 2794                     int cmd,
 2795                     _Inout_opt_ struct msqid_ds *buf
 2796                 );
 2797         }
 2798 512     AUE_SHMCTL      NOSTD {
 2799                 int shmctl(
 2800                     int shmid,
 2801                     int cmd,
 2802                     _Inout_opt_ struct shmid_ds *buf
 2803                 );
 2804         }
 2805 513     AUE_LPATHCONF   STD {
 2806                 int lpathconf(
 2807                     _In_z_ const char *path,
 2808                     int name
 2809                 );
 2810         }
 2811 514     AUE_NULL        OBSOL   cap_new
 2812 515     AUE_CAP_RIGHTS_GET      STD {
 2813                 int __cap_rights_get(
 2814                     int version,
 2815                     int fd,
 2816                     _Out_ cap_rights_t *rightsp
 2817                 );
 2818         }
 2819 516     AUE_CAP_ENTER   STD {
 2820                 int cap_enter(void);
 2821         }
 2822 517     AUE_CAP_GETMODE STD {
 2823                 int cap_getmode(
 2824                     _Out_ u_int *modep
 2825                 );
 2826         }
 2827 518     AUE_PDFORK      STD {
 2828                 int pdfork(
 2829                     _Out_ int *fdp,
 2830                     int flags
 2831                 );
 2832         }
 2833 519     AUE_PDKILL      STD {
 2834                 int pdkill(
 2835                     int fd,
 2836                     int signum
 2837                 );
 2838         }
 2839 520     AUE_PDGETPID    STD {
 2840                 int pdgetpid(
 2841                     int fd,
 2842                     _Out_ pid_t *pidp
 2843                 );
 2844         }
 2845 521     AUE_PDWAIT      UNIMPL  pdwait4
 2846 522     AUE_SELECT      STD {
 2847                 int pselect(
 2848                     int nd,
 2849                     _Inout_opt_ fd_set *in,
 2850                     _Inout_opt_ fd_set *ou,
 2851                     _Inout_opt_ fd_set *ex,
 2852                     _In_opt_ const struct timespec *ts,
 2853                     _In_opt_ const sigset_t *sm
 2854                 );
 2855         }
 2856 523     AUE_GETLOGINCLASS       STD {
 2857                 int getloginclass(
 2858                     _Out_writes_z_(namelen) char *namebuf,
 2859                     size_t namelen
 2860                 );
 2861         }
 2862 524     AUE_SETLOGINCLASS       STD {
 2863                 int setloginclass(
 2864                     _In_z_ const char *namebuf
 2865                 );
 2866         }
 2867 525     AUE_NULL        STD {
 2868                 int rctl_get_racct(
 2869                     _In_reads_bytes_(inbuflen) const void *inbufp,
 2870                     size_t inbuflen,
 2871                     _Out_writes_bytes_(outbuflen) void *outbufp,
 2872                     size_t outbuflen
 2873                 );
 2874         }
 2875 526     AUE_NULL        STD {
 2876                 int rctl_get_rules(
 2877                     _In_reads_bytes_(inbuflen) const void *inbufp,
 2878                     size_t inbuflen,
 2879                     _Out_writes_bytes_(outbuflen) void *outbufp,
 2880                     size_t outbuflen
 2881                 );
 2882         }
 2883 527     AUE_NULL        STD {
 2884                 int rctl_get_limits(
 2885                     _In_reads_bytes_(inbuflen) const void *inbufp,
 2886                     size_t inbuflen,
 2887                     _Out_writes_bytes_(outbuflen) void *outbufp,
 2888                     size_t outbuflen
 2889                 );
 2890         }
 2891 528     AUE_NULL        STD {
 2892                 int rctl_add_rule(
 2893                     _In_reads_bytes_(inbuflen) const void *inbufp,
 2894                     size_t inbuflen,
 2895                     _Out_writes_bytes_(outbuflen) void *outbufp,
 2896                     size_t outbuflen
 2897                 );
 2898         }
 2899 529     AUE_NULL        STD {
 2900                 int rctl_remove_rule(
 2901                     _In_reads_bytes_(inbuflen) const void *inbufp,
 2902                     size_t inbuflen,
 2903                     _Out_writes_bytes_(outbuflen) void *outbufp,
 2904                     size_t outbuflen
 2905                 );
 2906         }
 2907 530     AUE_POSIX_FALLOCATE     STD {
 2908                 int posix_fallocate(
 2909                     int fd,
 2910                     off_t offset,
 2911                     off_t len
 2912                 );
 2913         }
 2914 531     AUE_POSIX_FADVISE       STD {
 2915                 int posix_fadvise(
 2916                     int fd,
 2917                     off_t offset,
 2918                     off_t len,
 2919                     int advice
 2920                 );
 2921         }
 2922 532     AUE_WAIT6       STD {
 2923                 int wait6(
 2924                     idtype_t idtype,
 2925                     id_t id,
 2926                     _Out_opt_ int *status,
 2927                     int options,
 2928                     _Out_opt_ struct __wrusage *wrusage,
 2929                     _Out_opt_ siginfo_t *info
 2930                 );
 2931         }
 2932 533     AUE_CAP_RIGHTS_LIMIT    STD {
 2933                 int cap_rights_limit(
 2934                     int fd,
 2935                     _In_ cap_rights_t *rightsp
 2936                 );
 2937         }
 2938 534     AUE_CAP_IOCTLS_LIMIT    STD {
 2939                 int cap_ioctls_limit(
 2940                     int fd,
 2941                     _In_reads_(ncmds) const u_long *cmds,
 2942                     size_t ncmds
 2943                 );
 2944         }
 2945 535     AUE_CAP_IOCTLS_GET      STD {
 2946                 ssize_t cap_ioctls_get(
 2947                     int fd,
 2948                     _Out_writes_(maxcmds) u_long *cmds,
 2949                     size_t maxcmds
 2950                 );
 2951         }
 2952 536     AUE_CAP_FCNTLS_LIMIT    STD {
 2953                 int cap_fcntls_limit(
 2954                     int fd,
 2955                     uint32_t fcntlrights
 2956                 );
 2957         }
 2958 537     AUE_CAP_FCNTLS_GET      STD {
 2959                 int cap_fcntls_get(
 2960                     int fd,
 2961                     _Out_ uint32_t *fcntlrightsp
 2962                 );
 2963         }
 2964 538     AUE_BINDAT      STD {
 2965                 int bindat(
 2966                     int fd,
 2967                     int s,
 2968                     _In_reads_bytes_(namelen) const struct sockaddr *name,
 2969                     int namelen
 2970                 );
 2971         }
 2972 539     AUE_CONNECTAT   STD {
 2973                 int connectat(
 2974                     int fd,
 2975                     int s,
 2976                     _In_reads_bytes_(namelen) const struct sockaddr *name,
 2977                     int namelen
 2978                 );
 2979         }
 2980 540     AUE_CHFLAGSAT   STD {
 2981                 int chflagsat(
 2982                     int fd,
 2983                     _In_z_ const char *path,
 2984                     u_long flags,
 2985                     int atflag
 2986                 );
 2987         }
 2988 541     AUE_ACCEPT      STD {
 2989                 int accept4(
 2990                     int s,
 2991                     _Out_writes_bytes_opt_(*anamelen) struct sockaddr *name,
 2992                     _Inout_opt_ __socklen_t *anamelen,
 2993                     int flags
 2994                 );
 2995         }
 2996 542     AUE_PIPE        STD {
 2997                 int pipe2(
 2998                     _Out_writes_(2) int *fildes,
 2999                     int flags
 3000                 );
 3001         }
 3002 543     AUE_AIO_MLOCK   STD {
 3003                 int aio_mlock(
 3004                     _In_ struct aiocb *aiocbp
 3005                 );
 3006         }
 3007 544     AUE_PROCCTL     STD {
 3008                 int procctl(
 3009                     idtype_t idtype,
 3010                     id_t id,
 3011                     int com,
 3012                     _In_opt_ void *data
 3013                 );
 3014         }
 3015 545     AUE_POLL        STD {
 3016                 int ppoll(
 3017                     _Inout_updates_(nfds) struct pollfd *fds,
 3018                     u_int nfds,
 3019                     _In_opt_ const struct timespec *ts,
 3020                     _In_opt_ const sigset_t *set
 3021                 );
 3022         }
 3023 546     AUE_FUTIMES     STD {
 3024                 int futimens(
 3025                     int fd,
 3026                     _In_reads_(2) struct timespec *times
 3027                 );
 3028         }
 3029 547     AUE_FUTIMESAT   STD {
 3030                 int utimensat(
 3031                     int fd,
 3032                     _In_z_ const char *path,
 3033                     _In_reads_(2) struct timespec *times,
 3034                     int flag
 3035                 );
 3036         }
 3037 548     AUE_NULL        OBSOL   numa_getaffinity
 3038 549     AUE_NULL        OBSOL   numa_setaffinity
 3039 550     AUE_FSYNC       STD {
 3040                 int fdatasync(
 3041                     int fd
 3042                 );
 3043         }
 3044 551     AUE_FSTAT       STD {
 3045                 int fstat(
 3046                     int fd,
 3047                     _Out_ struct stat *sb
 3048                 );
 3049         }
 3050 552     AUE_FSTATAT     STD {
 3051                 int fstatat(
 3052                     int fd,
 3053                     _In_z_ const char *path,
 3054                     _Out_ struct stat *buf,
 3055                     int flag
 3056                 );
 3057         }
 3058 553     AUE_FHSTAT      STD {
 3059                 int fhstat(
 3060                     _In_ const struct fhandle *u_fhp,
 3061                     _Out_ struct stat *sb
 3062                 );
 3063         }
 3064 554     AUE_GETDIRENTRIES STD {
 3065                 ssize_t getdirentries(
 3066                     int fd,
 3067                     _Out_writes_bytes_(count) char *buf,
 3068                     size_t count,
 3069                     _Out_ off_t *basep
 3070                 );
 3071         }
 3072 555     AUE_STATFS      STD {
 3073                 int statfs(
 3074                     _In_z_ const char *path,
 3075                     _Out_ struct statfs *buf
 3076                 );
 3077         }
 3078 556     AUE_FSTATFS     STD {
 3079                 int fstatfs(
 3080                     int fd,
 3081                     _Out_ struct statfs *buf
 3082                 );
 3083         }
 3084 557     AUE_GETFSSTAT   STD {
 3085                 int getfsstat(
 3086                     _Out_writes_bytes_opt_(bufsize) struct statfs *buf,
 3087                     long bufsize,
 3088                     int mode
 3089                 );
 3090         }
 3091 558     AUE_FHSTATFS    STD {
 3092                 int fhstatfs(
 3093                     _In_ const struct fhandle *u_fhp,
 3094                     _Out_ struct statfs *buf
 3095                 );
 3096         }
 3097 559     AUE_MKNODAT     STD {
 3098                 int mknodat(
 3099                     int fd,
 3100                     _In_z_ const char *path,
 3101                     mode_t mode,
 3102                     dev_t dev
 3103                 );
 3104         }
 3105 560     AUE_KEVENT      STD {
 3106                 int kevent(
 3107                     int fd,
 3108                     _In_reads_opt_(nchanges) struct kevent *changelist,
 3109                     int nchanges,
 3110                     _Out_writes_opt_(nevents) struct kevent *eventlist,
 3111                     int nevents,
 3112                     _In_opt_ const struct timespec *timeout
 3113                 );
 3114         }
 3115 561     AUE_NULL        STD {
 3116                 int cpuset_getdomain(
 3117                     cpulevel_t level,
 3118                     cpuwhich_t which,
 3119                     id_t id,
 3120                     size_t domainsetsize,
 3121                     _Out_writes_bytes_(domainsetsize) domainset_t *mask,
 3122                     _Out_ int *policy
 3123                 );
 3124         }
 3125 562     AUE_NULL        STD {
 3126                 int cpuset_setdomain(
 3127                     cpulevel_t level,
 3128                     cpuwhich_t which,
 3129                     id_t id,
 3130                     size_t domainsetsize,
 3131                     _In_ domainset_t *mask,
 3132                     int policy
 3133                 );
 3134         }
 3135 563     AUE_NULL        STD {
 3136                 int getrandom(
 3137                     _Out_writes_bytes_(buflen) void *buf,
 3138                     size_t buflen,
 3139                     unsigned int flags
 3140                 );
 3141         }
 3142 
 3143 ; Please copy any additions and changes to the following compatability tables:
 3144 ; sys/compat/freebsd32/syscalls.master
 3145 ; vim: syntax=off

Cache object: 8fc314883093eaf1fcdba04dde203d9f


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.