sys/kern/syscalls.master

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