sys/kern/syscalls.master

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