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