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