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