sys/kern/syscalls.master

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