sys/kern/syscalls.master

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