sys/kern/syscalls.master

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