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