sys/kern/syscalls.master

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