sys/kern/syscalls.master

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