sys/kern/syscalls.master

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