sys/kern/syscalls.master

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