xref: /freebsd/sys/kern/syscalls.master (revision 2008043f386721d58158e37e0d7e50df8095942d)

;	from: @(#)syscalls.master	8.2 (Berkeley) 1/13/94
;
; System call name/number master file.
; Processed to created init_sysent.c, syscalls.c and syscall.h.

; New FreeBSD system calls should be added to the bottom of this file.

; Columns: number audit type name alt{name,tag,rtyp}/comments
;	number	system call number, must be in order
;	audit	the audit event associated with the system call
;		A value of AUE_NULL means no auditing, but it also means that
;		there is no audit event for the call at this time. For the
;		case where the event exists, but we don't want auditing, the
;		event should be #defined to AUE_NULL in audit_kevents.h.
;	type	one of STD, OBSOL, RESERVED, UNIMPL, SYSMUX, COMPAT*,
;		NODEF, NOARGS, NOPROTO, NOSTD
;		The COMPAT* options may be combined with one or more NO*
;		options separated by '|' with no spaces (e.g. COMPAT|NOARGS)
;		The CAPENABLED option may be ORed into a type.
;	name	pseudo-prototype of syscall routine
;		If one of the following alts is different, then all appear:
;	altname	name of system call if different
;	alttag	name of args struct tag if different from [o]`name'"_args"
;	altrtyp	return type if not int (bogus - syscalls always return int)
;		for UNIMPL/OBSOL, name continues with comments

; types:
;	STD	always included
;	COMPAT	included on COMPAT #ifdef
;	COMPAT4	included on COMPAT_FREEBSD4 #ifdef (FreeBSD 4 compat)
;	COMPAT6	included on COMPAT_FREEBSD6 #ifdef (FreeBSD 6 compat)
;	COMPAT7	included on COMPAT_FREEBSD7 #ifdef (FreeBSD 7 compat)
;	COMPAT10 included on COMPAT_FREEBSD10 #ifdef (FreeBSD 10 compat)
;	COMPAT11 included on COMPAT_FREEBSD11 #ifdef (FreeBSD 11 compat)
;	COMPAT12 included on COMPAT_FREEBSD12 #ifdef (FreeBSD 12 compat)
;	COMPAT13 included on COMPAT_FREEBSD13 #ifdef (FreeBSD 13 compat)
;	COMPAT14 included on COMPAT_FREEBSD14 #ifdef (FreeBSD 14 compat)
;	OBSOL	obsolete, not included in system, only specifies name
;	RESERVED reserved for local or vendor use (not for FreeBSD)
;	UNIMPL	not implemented, placeholder only
;	NOSTD	implemented but as a lkm that can be statically
;		compiled in; sysent entry will be filled with lkmressys
;		so the SYSCALL_MODULE macro works
;	NOARGS	same as STD except do not create structure in sys/sysproto.h
;	NODEF	same as STD except only have the entry in the syscall table
;		added.  Meaning - do not create structure or function
;		prototype in sys/sysproto.h
;	NOPROTO	same as STD except do not create structure or
;		function prototype in sys/sysproto.h.  Does add a
;		definition to syscall.h besides adding a sysent.
;	NOTSTATIC syscall is loadable
;	SYSMUX	syscall multiplexer.  No prototype, argument struct, or
;		handler is declared or used.  Handled in MD syscall code.
;	CAPENABLED syscall is allowed in capability mode
;
; To support programmatic generation of both the default ABI and 32-bit compat
; (freebsd32) we impose a number of restrictions on the types of system calls.
; For integer types:
;  - Bare int and long are allowed (long is a sign of a bad interface).
;  - Use u_int and u_long rather than "unsigned (int|long)".
;  - size_t is allowed.
;  - typedefs are allowed, but new signed types that vary between 32- and
;    64-bit ABIs must be added to makesyscalls.lua so it knows they require
;    handling.
;  - Always-64-bit types other than dev_t, id_t, and off_t must be added to
;    makesyscalls.lua.
; For pointers:
;  - Prefer structs to typedefs so an ABI-specific suffix (e.g., "32") can
;    be prepended (e.g., ucontext_t -> struct ucontext -> struct ucontext32).
;  - Pointers to objects (structs, unions, etc) containing any long, pointer,
;    or time_t arguments need _Contains_ annotations.  Such objects should be
;    padded such that all 64-bit types are 64-bit aligned.

; annotations:
;	SAL 2.0 annotations are used to specify how system calls treat
;	arguments that are passed using pointers. There are three basic
;	annotations.
;
;	_In_    Object pointed to will be read and not modified.
;	_Out_   Object pointed to will be written and not read.
;	_Inout_ Object pointed to will be written and read.
;
;	These annotations are used alone when the pointer refers to a single
;	object i.e. scalar types, structs, and pointers, and not NULL. Adding
;	the _opt_ suffix, e.g. _In_opt_, implies that the pointer may also
;	refer to NULL.
;
;	For pointers to arrays, additional suffixes are added:
;
;	_In_z_, _Out_z_, _Inout_z_:
;	    for a NUL terminated array e.g. a string.
;	_In_reads_z_(n),_Out_writes_z_(n), _Inout_updates_z_(n):
;	    for a NUL terminated array e.g. a string, of known length n bytes.
;	_In_reads_(n),_Out_writes_(n),_Inout_updates_(n):
;	    for an array of n elements.
;	_In_reads_bytes_(n), _Out_writes_bytes_(n), _Inout_updates_bytes(n):
;	    for a buffer of n-bytes.
;
;	In addition to SAL annotations, pointers are annotated to indicate
;	that they point to types that change between ABIs.  That means that
;	they contain long, pointer, or time_t types.  This is indicated with
;	a _Contains_ annotation followed immediately by one or more of:
;
;	long_	Object contains a direct (or typedef'd) long value and varies
;		between 32- and 64-bit ABIs.  This includes size_t.
;	ptr_	Object contains pointers (or intptr_t) and varies between
;		32- and 64-bit ABIs.
;	timet_	Object contains a time_t and varies between i386 and other
;		ABIs.

; #include's, #defines's, etc. may be included, and are copied to the output
; files. However, #ifdef, etc will be copied, but any lines that don't start
; with # will not. Caveat Emptor.

#include <sys/param.h>
#include <sys/sysent.h>
#include <sys/sysproto.h>
%%ABI_HEADERS%%

0	AUE_NULL	SYSMUX {
		int syscall(
		    int number,
		    ...
		);
	}
1	AUE_EXIT	STD|CAPENABLED {
		void exit(
		    int rval
		);
	}
2	AUE_FORK	STD|CAPENABLED {
		int fork(void);
	}
3	AUE_READ	STD|CAPENABLED {
		ssize_t read(
		    int fd,
		    _Out_writes_bytes_(nbyte) void *buf,
		    size_t nbyte
		);
	}
4	AUE_WRITE	STD|CAPENABLED {
		ssize_t write(
		    int fd,
		    _In_reads_bytes_(nbyte) const void *buf,
		    size_t nbyte
		);
	}
5	AUE_OPEN_RWTC	STD {
		int open(
		    _In_z_ const char *path,
		    int flags,
		    mode_t mode
		);
	}
; XXX should be		{ int open(const char *path, int flags, ...); }
; but we're not ready for varargs.
6	AUE_CLOSE	STD|CAPENABLED {
		int close(
		    int fd
		);
	}
7	AUE_WAIT4	STD {
		int wait4(
		    int pid,
		    _Out_opt_ int *status,
		    int options,
		    _Out_opt_ _Contains_long_timet_ struct rusage *rusage
		);
	}
8	AUE_CREAT	COMPAT {
		int creat(
		    _In_z_ const char *path,
		    int mode
		);
	}
9	AUE_LINK	STD {
		int link(
		    _In_z_ const char *path,
		    _In_z_ const char *link
		);
	}
10	AUE_UNLINK	STD {
		int unlink(
		    _In_z_ const char *path
		);
	}
11	AUE_NULL	OBSOL	execv
12	AUE_CHDIR	STD {
		int chdir(
		    _In_z_ const char *path
		);
	}
13	AUE_FCHDIR	STD {
		int fchdir(
		    int fd
		);
	}
14	AUE_MKNOD	COMPAT11 {
		int mknod(
		    _In_z_ const char *path,
		    int mode,
		    uint32_t dev
		);
	}
15	AUE_CHMOD	STD {
		int chmod(
		    _In_z_ const char *path,
		    mode_t mode
		);
	}
16	AUE_CHOWN	STD {
		int chown(
		    _In_z_ const char *path,
		    int uid,
		    int gid
		);
	}
17	AUE_NULL	STD|CAPENABLED {
		void *break(
		    _In_ char *nsize
		);
	}
18	AUE_GETFSSTAT	COMPAT4 {
		int getfsstat(
		    _Out_writes_bytes_opt_(bufsize) _Contains_long_ struct ostatfs *buf,
		    long bufsize,
		    int mode
		);
	}
19	AUE_LSEEK	COMPAT|CAPENABLED {
		long lseek(
		    int fd,
		    long offset,
		    int whence
		);
	}
20	AUE_GETPID	STD|CAPENABLED {
		pid_t getpid(void);
	}
21	AUE_MOUNT	STD {
		int mount(
		    _In_z_ const char *type,
		    _In_z_ const char *path,
		    int flags,
		    _In_opt_ void *data
		);
	}
22	AUE_UMOUNT	STD {
		int unmount(
		    _In_z_ const char *path,
		    int flags
		);
	}
23	AUE_SETUID	STD|CAPENABLED {
		int setuid(
		    uid_t uid
		);
	}
24	AUE_GETUID	STD|CAPENABLED {
		uid_t getuid(void);
	}
25	AUE_GETEUID	STD|CAPENABLED {
		uid_t geteuid(void);
	}
26	AUE_PTRACE	STD {
		int ptrace(
		    int req,
		    pid_t pid,
		    _Inout_opt_ _Contains_long_ptr_ caddr_t addr,
		    int data
		);
	}
27	AUE_RECVMSG	STD|CAPENABLED {
		ssize_t recvmsg(
		    int s,
		    _Inout_ _Contains_ptr_ struct msghdr *msg,
		    int flags
		);
	}
28	AUE_SENDMSG	STD|CAPENABLED {
		ssize_t sendmsg(
		    int s,
		    _In_ _Contains_ptr_ const struct msghdr *msg,
		    int flags
		);
	}
29	AUE_RECVFROM	STD|CAPENABLED {
		ssize_t recvfrom(
		    int s,
		    _Out_writes_bytes_(len) void *buf,
		    size_t len,
		    int flags,
		    _Out_writes_bytes_opt_(*fromlenaddr) struct sockaddr *from,
		    _Inout_opt_ __socklen_t *fromlenaddr
		);
	}
30	AUE_ACCEPT	STD|CAPENABLED {
		int accept(
		    int s,
		    _Out_writes_bytes_opt_(*anamelen) struct sockaddr *name,
		    _Inout_opt_ __socklen_t *anamelen
		);
	}
31	AUE_GETPEERNAME	STD|CAPENABLED {
		int getpeername(
		    int fdes,
		    _Out_writes_bytes_(*alen) struct sockaddr *asa,
		    _Inout_opt_ __socklen_t *alen
		);
	}
32	AUE_GETSOCKNAME	STD|CAPENABLED {
		int getsockname(
		    int fdes,
		    _Out_writes_bytes_(*alen) struct sockaddr *asa,
		    _Inout_ __socklen_t *alen
		);
	}
33	AUE_ACCESS	STD {
		int access(
		    _In_z_ const char *path,
		    int amode
		);
	}
34	AUE_CHFLAGS	STD {
		int chflags(
		    _In_z_ const char *path,
		    u_long flags
		);
	}
35	AUE_FCHFLAGS	STD|CAPENABLED {
		int fchflags(
		    int fd,
		    u_long flags
		);
	}
36	AUE_SYNC	STD|CAPENABLED {
		int sync(void);
	}
37	AUE_KILL	STD|CAPENABLED {
		int kill(
		    int pid,
		    int signum
		);
	}
38	AUE_STAT	COMPAT {
		int stat(
		    _In_z_ const char *path,
		    _Out_ _Contains_timet_ struct ostat *ub
		);
	}
39	AUE_GETPPID	STD|CAPENABLED {
		pid_t getppid(void);
	}
40	AUE_LSTAT	COMPAT {
		int lstat(
		    _In_z_ const char *path,
		    _Out_ _Contains_timet_ struct ostat *ub
		);
	}
41	AUE_DUP		STD|CAPENABLED {
		int dup(
		    u_int fd
		);
	}
42	AUE_PIPE	COMPAT10|CAPENABLED {
		int pipe(void);
	}
43	AUE_GETEGID	STD|CAPENABLED {
		gid_t getegid(void);
	}
44	AUE_PROFILE	STD|CAPENABLED {
		int profil(
		    _Out_writes_bytes_(size) char *samples,
		    size_t size,
		    size_t offset,
		    u_int scale
		);
	}
45	AUE_KTRACE	STD {
		int ktrace(
		    _In_z_ const char *fname,
		    int ops,
		    int facs,
		    int pid
		);
	}
46	AUE_SIGACTION	COMPAT|CAPENABLED {
		int sigaction(
		    int signum,
		    _In_opt_ _Contains_ptr_ struct osigaction *nsa,
		    _Out_opt_ _Contains_ptr_ struct osigaction *osa
		);
	}
47	AUE_GETGID	STD|CAPENABLED {
		gid_t getgid(void);
	}
48	AUE_SIGPROCMASK	COMPAT|CAPENABLED {
		int sigprocmask(
		    int how,
		    osigset_t mask
		);
	}
; XXX note nonstandard (bogus) calling convention - the libc stub passes
; us the mask, not a pointer to it, and we return the old mask as the
; (int) return value.
49	AUE_GETLOGIN	STD|CAPENABLED {
		int getlogin(
		    _Out_writes_z_(namelen) char *namebuf,
		    u_int namelen
		);
	}
50	AUE_SETLOGIN	STD {
		int setlogin(
		    _In_z_ const char *namebuf
		);
	}
51	AUE_ACCT	STD {
		int acct(
		    _In_z_ const char *path
		);
	}
52	AUE_SIGPENDING	COMPAT|CAPENABLED {
		int sigpending(void);
	}
53	AUE_SIGALTSTACK	STD|CAPENABLED {
		int sigaltstack(
		    _In_opt_ _Contains_long_ptr_ const struct sigaltstack *ss,
		    _Out_opt_ _Contains_long_ptr_ struct sigaltstack *oss
		);
	}
54	AUE_IOCTL	STD|CAPENABLED {
		int ioctl(
		    int fd,
		    u_long com,
		    _Inout_opt_ _Contains_long_ptr_ char *data
		);
	}
55	AUE_REBOOT	STD {
		int reboot(
		    int opt
		);
	}
56	AUE_REVOKE	STD {
		int revoke(
		    _In_z_ const char *path
		);
	}
57	AUE_SYMLINK	STD {
		int symlink(
		    _In_z_ const char *path,
		    _In_z_ const char *link
		);
	}
58	AUE_READLINK	STD {
		ssize_t readlink(
		    _In_z_ const char *path,
		    _Out_writes_z_(count) char *buf,
		    size_t count
		);
	}
59	AUE_EXECVE	STD {
		int execve(
		    _In_z_ const char *fname,
		    _In_z_ char **argv,
		    _In_z_ char **envv
		);
	}
60	AUE_UMASK	STD|CAPENABLED {
		mode_t umask(
		    mode_t newmask
		);
	}
61	AUE_CHROOT	STD {
		int chroot(
		    _In_z_ const char *path
		);
	}
62	AUE_FSTAT	COMPAT|CAPENABLED {
		int fstat(
		    int fd,
		    _Out_ _Contains_timet_ struct ostat *sb
		);
	}
63	AUE_NULL	COMPAT {
		int getkerninfo(
		    int op,
		    _Out_writes_bytes_opt(*size) char *where,
		    _Inout_opt_ size_t *size,
		    int arg
		);
	}
64	AUE_NULL	COMPAT|CAPENABLED {
		int getpagesize(void);
	}
65	AUE_MSYNC	STD|CAPENABLED {
		int msync(
		    _In_ void *addr,
		    size_t len,
		    int flags
		);
	}
66	AUE_VFORK	STD {
		int vfork(void);
	}
67	AUE_NULL	OBSOL	vread
68	AUE_NULL	OBSOL	vwrite
69	AUE_SBRK	STD|CAPENABLED {
		int sbrk(
		    int incr
		);
	}
70	AUE_SSTK	STD|CAPENABLED {
		int sstk(
		    int incr
		);
	}
71	AUE_MMAP	COMPAT|CAPENABLED {
		void *mmap(
		    _In_ void *addr,
		    int len,
		    int prot,
		    int flags,
		    int fd,
		    long pos
		);
	}
72	AUE_O_VADVISE	COMPAT11 {
		int vadvise(
		    int anom
		);
	}
73	AUE_MUNMAP	STD|CAPENABLED {
		int munmap(
		    _In_ void *addr,
		    size_t len
		);
	}
74	AUE_MPROTECT	STD|CAPENABLED {
		int mprotect(
		    _In_ void *addr,
		    size_t len,
		    int prot
		);
	}
75	AUE_MADVISE	STD|CAPENABLED {
		int madvise(
		    _In_ void *addr,
		    size_t len,
		    int behav
		);
	}
76	AUE_NULL	OBSOL	vhangup
77	AUE_NULL	OBSOL	vlimit
78	AUE_MINCORE	STD|CAPENABLED {
		int mincore(
		    _In_ const void *addr,
		    size_t len,
		    _Out_writes_bytes_(len/PAGE_SIZE) char *vec
		);
	}
79	AUE_GETGROUPS	STD|CAPENABLED {
		int getgroups(
		    int gidsetsize,
		    _Out_writes_opt_(gidsetsize) gid_t *gidset
		);
	}
80	AUE_SETGROUPS	STD {
		int setgroups(
		    int gidsetsize,
		    _In_reads_(gidsetsize) const gid_t *gidset
		);
	}
81	AUE_GETPGRP	STD|CAPENABLED {
		int getpgrp(void);
	}
82	AUE_SETPGRP	STD {
		int setpgid(
		    int pid,
		    int pgid
		);
	}
83	AUE_SETITIMER	STD|CAPENABLED {
		int setitimer(
		    int which,
		    _In_ _Contains_timet_ const struct itimerval *itv,
		    _Out_opt_ _Contains_timet_ struct itimerval *oitv
		);
	}
84	AUE_WAIT4	COMPAT {
		int wait(void);
	}
85	AUE_SWAPON	STD {
		int swapon(
		    _In_z_ const char *name
		);
	}
86	AUE_GETITIMER	STD|CAPENABLED {
		int getitimer(
		    int which,
		    _Out_ _Contains_timet_ struct itimerval *itv
		);
	}
87	AUE_SYSCTL	COMPAT|CAPENABLED {
		int gethostname(
		    _Out_writes_z_(len) char *hostname,
		    u_int len
		);
	}
88	AUE_SYSCTL	COMPAT {
		int sethostname(
		    _In_reads_z_(len) char *hostname,
		    u_int len
		);
	}
89	AUE_GETDTABLESIZE	STD|CAPENABLED {
		int getdtablesize(void);
	}
90	AUE_DUP2	STD|CAPENABLED {
		int dup2(
		    u_int from,
		    u_int to
		);
	}
91	AUE_NULL	RESERVED
92	AUE_FCNTL	STD|CAPENABLED {
		int fcntl(
		    int fd,
		    int cmd,
		    long arg
		);
	}
; XXX should be { int fcntl(int fd, int cmd, ...); }
; but we're not ready for varargs.
93	AUE_SELECT	STD|CAPENABLED {
		int select(
		    int nd,
		    _Inout_opt_ fd_set *in,
		    _Inout_opt_ fd_set *ou,
		    _Inout_opt_ fd_set *ex,
		    _In_opt_ _Contains_long_timet_ struct timeval *tv
		);
	}
94	AUE_NULL	RESERVED
95	AUE_FSYNC	STD|CAPENABLED {
		int fsync(
		    int fd
		);
	}
96	AUE_SETPRIORITY	STD|CAPENABLED {
		int setpriority(
		    int which,
		    int who,
		    int prio
		);
	}
97	AUE_SOCKET	STD|CAPENABLED {
		int socket(
		    int domain,
		    int type,
		    int protocol
		);
	}
98	AUE_CONNECT	STD {
		int connect(
		    int s,
		    _In_reads_bytes_(namelen) const struct sockaddr *name,
		    __socklen_t namelen
		);
	}
99	AUE_ACCEPT	COMPAT|CAPENABLED {
		int accept(
		    int s,
		    _Out_writes_bytes_opt_(*anamelen) struct sockaddr *name,
		    __socklen_t *anamelen
		);
	}
100	AUE_GETPRIORITY	STD|CAPENABLED {
		int getpriority(
		    int which,
		    int who
		);
	}
101	AUE_SEND	COMPAT|CAPENABLED {
		int send(
		    int s,
		    _In_reads_bytes_(len) const void *buf,
		    int len,
		    int flags
		);
	}
102	AUE_RECV	COMPAT|CAPENABLED {
		int recv(
		    int s,
		    _Out_writes_bytes_(len) void *buf,
		    int len,
		    int flags
		);
	}
103	AUE_SIGRETURN	COMPAT|CAPENABLED {
		int sigreturn(
		    _In_ struct osigcontext *sigcntxp
		);
	}
104	AUE_BIND	STD {
		int bind(
		    int s,
		    _In_reads_bytes_(namelen) const struct sockaddr *name,
		    __socklen_t namelen
		);
	}
105	AUE_SETSOCKOPT	STD|CAPENABLED {
		int setsockopt(
		    int s,
		    int level,
		    int name,
		    _In_reads_bytes_opt_(valsize) const void *val,
		    __socklen_t valsize
		);
	}
106	AUE_LISTEN	STD|CAPENABLED {
		int listen(
		    int s,
		    int backlog
		);
	}
107	AUE_NULL	OBSOL	vtimes
108	AUE_NULL	COMPAT|CAPENABLED {
		int sigvec(
		    int signum,
		    _In_opt_ _Contains_ptr_ struct sigvec *nsv,
		    _Out_opt_ _Contains_ptr_ struct sigvec *osv
		);
	}
109	AUE_NULL	COMPAT|CAPENABLED {
		int sigblock(
		    int mask
		);
	}
110	AUE_NULL	COMPAT|CAPENABLED {
		int sigsetmask(
		    int mask
		);
	}
111	AUE_NULL	COMPAT|CAPENABLED {
		int sigsuspend(
		    osigset_t mask
		);
	}
; XXX note nonstandard (bogus) calling convention - the libc stub passes
; us the mask, not a pointer to it.
112	AUE_NULL	COMPAT|CAPENABLED {
		int sigstack(
		    _In_opt_ _Contains_ptr_ struct sigstack *nss,
		    _Out_opt_ _Contains_ptr_ struct sigstack *oss
		);
	}
113	AUE_RECVMSG	COMPAT|CAPENABLED {
		int recvmsg(
		    int s,
		    _Inout_ _Contains_ptr_ struct omsghdr *msg,
		    int flags
		);
	}
114	AUE_SENDMSG	COMPAT|CAPENABLED {
		int sendmsg(
		    int s,
		    _In_ _Contains_ptr_ const struct omsghdr *msg,
		    int flags
		);
	}
115	AUE_NULL	OBSOL	vtrace
116	AUE_GETTIMEOFDAY	STD|CAPENABLED {
		int gettimeofday(
		    _Out_ _Contains_long_timet_ struct timeval *tp,
		    _Out_opt_ struct timezone *tzp
		);
	}
117	AUE_GETRUSAGE	STD|CAPENABLED {
		int getrusage(
		    int who,
		    _Out_ _Contains_long_ struct rusage *rusage
		);
	}
118	AUE_GETSOCKOPT	STD|CAPENABLED {
		int getsockopt(
		    int s,
		    int level,
		    int name,
		    _Out_writes_bytes_opt_(*avalsize) void *val,
		    _Inout_ __socklen_t *avalsize
		);
	}
119	AUE_NULL	RESERVED
120	AUE_READV	STD|CAPENABLED {
		int readv(
		    int fd,
		    _Inout_updates_(iovcnt) _Contains_long_ptr_ struct iovec *iovp,
		    u_int iovcnt
		);
	}
121	AUE_WRITEV	STD|CAPENABLED {
		int writev(
		    int fd,
		    _In_reads_opt_(iovcnt) _Contains_long_ptr_ struct iovec *iovp,
		    u_int iovcnt
		);
	}
122	AUE_SETTIMEOFDAY	STD {
		int settimeofday(
		    _In_ _Contains_long_timet_ const struct timeval *tv,
		    _In_opt_ const struct timezone *tzp
		);
	}
123	AUE_FCHOWN	STD|CAPENABLED {
		int fchown(
		    int fd,
		    int uid,
		    int gid
		);
	}
124	AUE_FCHMOD	STD|CAPENABLED {
		int fchmod(
		    int fd,
		    mode_t mode
		);
	}
125	AUE_RECVFROM	COMPAT|CAPENABLED {
		int recvfrom(
		    int s,
		    _Out_writes_(len) void *buf,
		    size_t len,
		    int flags,
		    _Out_writes_bytes_(*fromlenaddr) struct sockaddr *from,
		    _Inout_ __socklen_t *fromlenaddr
		);
	}
126	AUE_SETREUID	STD|CAPENABLED {
		int setreuid(
		    int ruid,
		    int euid
		);
	}
127	AUE_SETREGID	STD|CAPENABLED {
		int setregid(
		    int rgid,
		    int egid
		);
	}
128	AUE_RENAME	STD {
		int rename(
		    _In_z_ const char *from,
		    _In_z_ const char *to
		);
	}
129	AUE_TRUNCATE	COMPAT {
		int truncate(
		    _In_z_ const char *path,
		    long length
		);
	}
130	AUE_FTRUNCATE	COMPAT|CAPENABLED {
		int ftruncate(
		    int fd,
		    long length
		);
	}
131	AUE_FLOCK	STD|CAPENABLED {
		int flock(
		    int fd,
		    int how
		);
	}
132	AUE_MKFIFO	STD {
		int mkfifo(
		    _In_z_ const char *path,
		    mode_t mode
		);
	}
133	AUE_SENDTO	STD|CAPENABLED {
		ssize_t sendto(
		    int s,
		    _In_reads_bytes_(len) const void *buf,
		    size_t len,
		    int flags,
		    _In_reads_bytes_opt_(tolen) const struct sockaddr *to,
		    __socklen_t tolen
		);
	}
134	AUE_SHUTDOWN	STD|CAPENABLED {
		int shutdown(
		    int s,
		    int how
		);
	}
135	AUE_SOCKETPAIR	STD|CAPENABLED {
		int socketpair(
		    int domain,
		    int type,
		    int protocol,
		    _Out_writes_(2) int *rsv
		);
	}
136	AUE_MKDIR	STD {
		int mkdir(
		    _In_z_ const char *path,
		    mode_t mode
		);
	}
137	AUE_RMDIR	STD {
		int rmdir(
		    _In_z_ const char *path
		);
	}
138	AUE_UTIMES	STD {
		int utimes(
		    _In_z_ const char *path,
		    _In_ _Contains_long_timet_ const struct timeval *tptr
		);
	}
139	AUE_NULL	OBSOL	sigreturn
140	AUE_ADJTIME	STD {
		int adjtime(
		    _In_ _Contains_long_timet_ const struct timeval *delta,
		    _Out_opt_ _Contains_long_timet_ struct timeval *olddelta
		);
	}
141	AUE_GETPEERNAME	COMPAT|CAPENABLED {
		int getpeername(
		    int fdes,
		    _Out_writes_bytes_(*alen) struct sockaddr *asa,
		    _Inout_opt_ __socklen_t *alen
		);
	}
142	AUE_SYSCTL	COMPAT|CAPENABLED {
		long gethostid(void);
	}
143	AUE_SYSCTL	COMPAT {
		int sethostid(
		    long hostid
		);
	}
144	AUE_GETRLIMIT	COMPAT|CAPENABLED {
		int getrlimit(
		    u_int which,
		    _Out_ struct orlimit *rlp
		);
	}
145	AUE_SETRLIMIT	COMPAT|CAPENABLED {
		int setrlimit(
		    u_int which,
		    _Out_ struct orlimit *rlp
		);
	}
146	AUE_KILLPG	COMPAT {
		int killpg(
		    int pgid,
		    int signum
		);
	}
147	AUE_SETSID	STD|CAPENABLED {
		int setsid(void);
	}
148	AUE_QUOTACTL	STD {
		int quotactl(
		    _In_z_ const char *path,
		    int cmd,
		    int uid,
		    _In_ void *arg
		);
	}
149	AUE_O_QUOTA	COMPAT {
		int quota(void);
	}
150	AUE_GETSOCKNAME	COMPAT|CAPENABLED {
		int getsockname(
		    int fdes,
		    _Out_writes_bytes_(*alen) struct sockaddr *asa,
		    _Inout_ __socklen_t *alen
		);
	}
151-153	AUE_NULL	RESERVED
; 154 is initialised by the NLM code, if present.
154	AUE_NULL	NOSTD {
		int nlm_syscall(
		    int debug_level,
		    int grace_period,
		    int addr_count,
		    _In_reads_(addr_count) char **addrs
		);
	}
; 155 is initialized by the NFS code, if present.
155	AUE_NFS_SVC	NOSTD {
		int nfssvc(
		    int flag,
		    _In_ void *argp
		);
	}
156	AUE_GETDIRENTRIES	COMPAT|CAPENABLED {
		int getdirentries(
		    int fd,
		    _Out_writes_bytes_(count) char *buf,
		    u_int count,
		    _Out_opt_ long *basep
		);
	}
157	AUE_STATFS	COMPAT4 {
		int statfs(
		    _In_z_ const char *path,
		    _Out_ _Contains_long_ struct ostatfs *buf
		);
	}
158	AUE_FSTATFS	COMPAT4|CAPENABLED {
		int fstatfs(
		    int fd,
		    _Out_ _Contains_long_ struct ostatfs *buf
		);
	}
159	AUE_NULL	RESERVED
160	AUE_LGETFH	STD {
		int lgetfh(
		    _In_z_ const char *fname,
		    _Out_ struct fhandle *fhp
		);
	}
161	AUE_NFS_GETFH	STD {
		int getfh(
		    _In_z_ const char *fname,
		    _Out_ struct fhandle *fhp
		);
	}
162	AUE_SYSCTL	COMPAT4|CAPENABLED {
		int getdomainname(
		    _Out_writes_z_(len) char *domainname,
		    int len
		);
	}
163	AUE_SYSCTL	COMPAT4 {
		int setdomainname(
		    _In_reads_z_(len) char *domainname,
		    int len
		);
	}
164	AUE_NULL	COMPAT4 {
		int uname(
		    _Out_ struct utsname *name
		);
	}
165	AUE_SYSARCH	STD|CAPENABLED {
		int sysarch(
		    int op,
		    _In_z_ char *parms
		);
	}
166	AUE_RTPRIO	STD|CAPENABLED {
		int rtprio(
		    int function,
		    pid_t pid,
		    _Inout_ struct rtprio *rtp
		);
	}
167-168	AUE_NULL	RESERVED
169	AUE_SEMSYS	NOSTD {
		int semsys(
		    int which,
		    int a2,
		    int a3,
		    int a4,
		    int a5
		);
	}
; XXX should be { int semsys(int which, ...); }
170	AUE_MSGSYS	NOSTD {
		int msgsys(
		    int which,
		    int a2,
		    int a3,
		    int a4,
		    int a5,
		    int a6
		);
	}
; XXX should be { int msgsys(int which, ...); }
171	AUE_SHMSYS	NOSTD {
		int shmsys(
		    int which,
		    int a2,
		    int a3,
		    int a4
		);
	}
; XXX should be { int shmsys(int which, ...); }
172	AUE_NULL	RESERVED
173	AUE_PREAD	COMPAT6|CAPENABLED {
		ssize_t pread(
		    int fd,
		    _Out_writes_bytes_(nbyte) void *buf,
		    size_t nbyte,
		    int pad,
		    off_t offset
		);
	}
174	AUE_PWRITE	COMPAT6|CAPENABLED {
		ssize_t pwrite(
		    int fd,
		    _In_reads_bytes_(nbyte) const void *buf,
		    size_t nbyte,
		    int pad,
		    off_t offset
		);
	}
175	AUE_SETFIB	STD {
		int setfib(
		    int fibnum
		);
	}
176	AUE_NTP_ADJTIME	STD {
		int ntp_adjtime(
		    _Inout_ _Contains_long_ struct timex *tp
		);
	}
177-180	AUE_NULL	RESERVED
181	AUE_SETGID	STD|CAPENABLED {
		int setgid(
		    gid_t gid
		);
	}
182	AUE_SETEGID	STD|CAPENABLED {
		int setegid(
		    gid_t egid
		);
	}
183	AUE_SETEUID	STD|CAPENABLED {
		int seteuid(
		    uid_t euid
		);
	}
184	AUE_NULL	OBSOL	lfs_bmapv
185	AUE_NULL	OBSOL	lfs_markv
186	AUE_NULL	OBSOL	lfs_segclean
187	AUE_NULL	OBSOL	lfs_segwait
188	AUE_STAT	COMPAT11 {
		int stat(
		    _In_z_ const char *path,
		    _Out_ _Contains_timet_ struct freebsd11_stat *ub
		);
	}
189	AUE_FSTAT	COMPAT11|CAPENABLED {
		int fstat(
		    int fd,
		    _Out_ _Contains_timet_ struct freebsd11_stat *sb
		);
	}
190	AUE_LSTAT	COMPAT11 {
		int lstat(
		    _In_z_ const char *path,
		    _Out_ _Contains_timet_ struct freebsd11_stat *ub
		);
	}
191	AUE_PATHCONF	STD {
		int pathconf(
		    _In_z_ const char *path,
		    int name
		);
	}
192	AUE_FPATHCONF	STD|CAPENABLED {
		int fpathconf(
		    int fd,
		    int name
		);
	}
193	AUE_NULL	RESERVED
194	AUE_GETRLIMIT	STD|CAPENABLED {
		int getrlimit(
		    u_int which,
		    _Out_ struct rlimit *rlp
		);
	}
195	AUE_SETRLIMIT	STD|CAPENABLED {
		int setrlimit(
		    u_int which,
		    _In_ struct rlimit *rlp
		);
	}
196	AUE_GETDIRENTRIES	COMPAT11|CAPENABLED {
		int getdirentries(
		    int fd,
		    _Out_writes_bytes_(count) char *buf,
		    u_int count,
		    _Out_opt_ long *basep
		);
	}
197	AUE_MMAP	COMPAT6|CAPENABLED {
		void *mmap(
		    _In_ void *addr,
		    size_t len,
		    int prot,
		    int flags,
		    int fd,
		    int pad,
		    off_t pos
		);
	}
198	AUE_NULL	SYSMUX {
		int __syscall(
		    int64_t number,
		    ...
		);
	}
199	AUE_LSEEK	COMPAT6|CAPENABLED {
		off_t lseek(
		    int fd,
		    int pad,
		    off_t offset,
		    int whence
		);
	}
200	AUE_TRUNCATE	COMPAT6 {
		int truncate(
		    _In_z_ const char *path,
		    int pad,
		    off_t length
		);
	}
201	AUE_FTRUNCATE	COMPAT6|CAPENABLED {
		int ftruncate(
		    int fd,
		    int pad,
		    off_t length
		);
	}
202	AUE_SYSCTL	STD|CAPENABLED {
		int __sysctl(
		    _In_reads_(namelen) int *name,
		    u_int namelen,
		    _Out_writes_bytes_opt_(*oldlenp) void *old,
		    _Inout_opt_ size_t *oldlenp,
		    _In_reads_bytes_opt_(newlen) const void *new,
		    size_t newlen
		);
	}
203	AUE_MLOCK	STD|CAPENABLED {
		int mlock(
		    _In_ const void *addr,
		    size_t len
		);
	}
204	AUE_MUNLOCK	STD|CAPENABLED {
		int munlock(
		    _In_ const void *addr,
		    size_t len
		);
	}
205	AUE_UNDELETE	STD {
		int undelete(
		    _In_z_ const char *path
		);
	}
206	AUE_FUTIMES	STD|CAPENABLED {
		int futimes(
		    int fd,
		    _In_reads_(2) _Contains_long_timet_ const struct timeval *tptr
		);
	}
207	AUE_GETPGID	STD|CAPENABLED {
		int getpgid(
		    pid_t pid
		);
	}
208	AUE_NULL	RESERVED
209	AUE_POLL	STD|CAPENABLED {
		int poll(
		    _Inout_updates_(nfds) struct pollfd *fds,
		    u_int nfds,
		    int timeout
		);
	}
;
; The following are reserved for loadable syscalls
;
210	AUE_NULL	NODEF|NOTSTATIC	lkmnosys lkmnosys nosys_args int
211	AUE_NULL	NODEF|NOTSTATIC	lkmnosys lkmnosys nosys_args int
212	AUE_NULL	NODEF|NOTSTATIC	lkmnosys lkmnosys nosys_args int
213	AUE_NULL	NODEF|NOTSTATIC	lkmnosys lkmnosys nosys_args int
214	AUE_NULL	NODEF|NOTSTATIC	lkmnosys lkmnosys nosys_args int
215	AUE_NULL	NODEF|NOTSTATIC	lkmnosys lkmnosys nosys_args int
216	AUE_NULL	NODEF|NOTSTATIC	lkmnosys lkmnosys nosys_args int
217	AUE_NULL	NODEF|NOTSTATIC	lkmnosys lkmnosys nosys_args int
218	AUE_NULL	NODEF|NOTSTATIC	lkmnosys lkmnosys nosys_args int
219	AUE_NULL	NODEF|NOTSTATIC	lkmnosys lkmnosys nosys_args int

220	AUE_SEMCTL	COMPAT7|NOSTD {
		int __semctl(
		    int semid,
		    int semnum,
		    int cmd,
		    _Contains_ptr_ union semun_old *arg
		);
	}
221	AUE_SEMGET	NOSTD {
		int semget(
		    key_t key,
		    int nsems,
		    int semflg
		);
	}
222	AUE_SEMOP	NOSTD {
		int semop(
		    int semid,
		    _In_reads_(nsops) struct sembuf *sops,
		    size_t nsops
		);
	}
223	AUE_NULL	OBSOL	semconfig
224	AUE_MSGCTL	COMPAT7|NOSTD {
		int msgctl(
		    int msqid,
		    int cmd,
		    _Contains_long_ptr_timet_ struct msqid_ds_old *buf
		);
	}
225	AUE_MSGGET	NOSTD {
		int msgget(
		    key_t key,
		    int msgflg
		);
	}
226	AUE_MSGSND	NOSTD {
		int msgsnd(
		    int msqid,
		    _In_reads_bytes_(msgsz) _Contains_long_ const void *msgp,
		    size_t msgsz,
		    int msgflg
		);
	}
227	AUE_MSGRCV	NOSTD {
		ssize_t msgrcv(
		    int msqid,
		    _Out_writes_bytes_(msgsz) _Contains_long_ void *msgp,
		    size_t msgsz,
		    long msgtyp,
		    int msgflg
		);
	}
228	AUE_SHMAT	NOSTD {
		void *shmat(
		    int shmid,
		    _In_ const void *shmaddr,
		    int shmflg
		);
	}
229	AUE_SHMCTL	COMPAT7|NOSTD {
		int shmctl(
		    int shmid,
		    int cmd,
		    _Inout_opt_ _Contains_long_ struct shmid_ds_old *buf
		);
	}
230	AUE_SHMDT	NOSTD {
		int shmdt(
		    _In_ const void *shmaddr
		);
	}
231	AUE_SHMGET	NOSTD {
		int shmget(
		    key_t key,
		    size_t size,
		    int shmflg
		);
	}
232	AUE_NULL	STD|CAPENABLED {
		int clock_gettime(
		    clockid_t clock_id,
		    _Out_ _Contains_long_timet_ struct timespec *tp
		);
	}
233	AUE_CLOCK_SETTIME	STD {
		int clock_settime(
		    clockid_t clock_id,
		    _In_ _Contains_long_timet_ const struct timespec *tp
		);
	}
234	AUE_NULL	STD|CAPENABLED {
		int clock_getres(
		    clockid_t clock_id,
		    _Out_ _Contains_long_timet_ struct timespec *tp
		);
	}
235	AUE_NULL	STD|CAPENABLED {
		int ktimer_create(
		    clockid_t clock_id,
		    _In_ _Contains_long_ptr_ struct sigevent *evp,
		    _Out_ int *timerid
		);
	}
236	AUE_NULL	STD|CAPENABLED {
		int ktimer_delete(
		    int timerid
		);
	}
237	AUE_NULL	STD|CAPENABLED {
		int ktimer_settime(
		    int timerid,
		    int flags,
		    _In_ _Contains_long_timet_ const struct itimerspec *value,
		    _Out_opt_ _Contains_long_timet_ struct itimerspec *ovalue
		);
	}
238	AUE_NULL	STD|CAPENABLED {
		int ktimer_gettime(
		    int timerid,
		    _Out_ _Contains_long_timet_ struct itimerspec *value
		);
	}
239	AUE_NULL	STD|CAPENABLED {
		int ktimer_getoverrun(
		    int timerid
		);
	}
240	AUE_NULL	STD|CAPENABLED {
		int nanosleep(
		    _In_ _Contains_long_timet_ const struct timespec *rqtp,
		    _Out_opt_ _Contains_long_timet_ struct timespec *rmtp
		);
	}
241	AUE_NULL	STD {
		int ffclock_getcounter(
		    _Out_ ffcounter *ffcount
		);
	}
242	AUE_NULL	STD {
		int ffclock_setestimate(
		    _In_ _Contains_timet_ struct ffclock_estimate *cest
		);
	}
243	AUE_NULL	STD {
		int ffclock_getestimate(
		    _Out_ _Contains_timet_ struct ffclock_estimate *cest
		);
	}
244	AUE_NULL	STD {
		int clock_nanosleep(
		    clockid_t clock_id,
		    int flags,
		    _In_ _Contains_long_timet_ const struct timespec *rqtp,
		    _Out_opt_ _Contains_long_timet_ struct timespec *rmtp
		);
	}
245-246	AUE_NULL	RESERVED
247	AUE_NULL	STD {
		int clock_getcpuclockid2(
		    id_t id,
		    int which,
		    _Out_ clockid_t *clock_id
		);
	}
248	AUE_NULL	STD|CAPENABLED {
		int ntp_gettime(
		    _Out_ _Contains_long_timet_ struct ntptimeval *ntvp
		);
	}
249	AUE_NULL	RESERVED
250	AUE_MINHERIT	STD|CAPENABLED {
		int minherit(
		    _In_ void *addr,
		    size_t len,
		    int inherit
		);
	}
251	AUE_RFORK	STD {
		int rfork(
		    int flags
		);
	}
252	AUE_POLL	OBSOL	openbsd_poll
253	AUE_ISSETUGID	STD|CAPENABLED {
		int issetugid(void);
	}
254	AUE_LCHOWN	STD {
		int lchown(
		    _In_z_ const char *path,
		    int uid,
		    int gid
		);
	}
255	AUE_AIO_READ	STD|CAPENABLED {
		int aio_read(
		    _Inout_ _Contains_long_ptr_ struct aiocb *aiocbp
		);
	}
256	AUE_AIO_WRITE	STD|CAPENABLED {
		int aio_write(
		    _Inout_ _Contains_long_ptr_ struct aiocb *aiocbp
		);
	}
257	AUE_LIO_LISTIO	STD|CAPENABLED {
		int lio_listio(
		    int mode,
		    _Inout_updates_(nent) _Contains_long_ptr_ struct aiocb * const *acb_list,
		    int nent,
		    _In_opt_ _Contains_long_ptr_ struct sigevent *sig
		);
	}
258-271	AUE_NULL	RESERVED
272	AUE_O_GETDENTS	COMPAT11|CAPENABLED {
		int getdents(
		    int fd,
		    _Out_writes_bytes_(count) char *buf,
		    size_t count
		);
	}
273	AUE_NULL	RESERVED
274	AUE_LCHMOD	STD {
		int lchmod(
		    _In_z_ const char *path,
		    mode_t mode
		);
	}
275	AUE_NULL	OBSOL	netbsd_lchown
276	AUE_LUTIMES	STD {
		int lutimes(
		    _In_z_ const char *path,
		    _In_ _Contains_long_timet_ const struct timeval *tptr
		);
	}
277	AUE_NULL	OBSOL	netbsd_msync
278	AUE_STAT	COMPAT11 {
		int nstat(
		    _In_z_ const char *path,
		    _Out_ _Contains_long_timet_ struct nstat *ub
		);
	}
279	AUE_FSTAT	COMPAT11 {
		int nfstat(
		    int fd,
		    _Out_ _Contains_long_timet_ struct nstat *sb
		);
	}
280	AUE_LSTAT	COMPAT11 {
		int nlstat(
		    _In_z_ const char *path,
		    _Out_ _Contains_long_timet_ struct nstat *ub
		);
	}
281-288	AUE_NULL	RESERVED
289	AUE_PREADV	STD|CAPENABLED {
		ssize_t preadv(
		    int fd,
		    _In_reads_(iovcnt) _Contains_long_ptr_ struct iovec *iovp,
		    u_int iovcnt,
		    off_t offset
		);
	}
290	AUE_PWRITEV	STD|CAPENABLED {
		ssize_t pwritev(
		    int fd,
		    _In_reads_(iovcnt) _Contains_long_ptr_ struct iovec *iovp,
		    u_int iovcnt,
		    off_t offset
		);
	}
291-296	AUE_NULL	RESERVED
297	AUE_FHSTATFS	COMPAT4 {
		int fhstatfs(
		    _In_ const struct fhandle *u_fhp,
		    _Out_ _Contains_long_ struct ostatfs *buf
		);
	}
298	AUE_FHOPEN	STD {
		int fhopen(
		    _In_ const struct fhandle *u_fhp,
		    int flags
		);
	}
299	AUE_FHSTAT	COMPAT11 {
		int fhstat(
		    _In_ const struct fhandle *u_fhp,
		    _Out_ _Contains_long_timet_ struct freebsd11_stat *sb
		);
	}
300	AUE_NULL	STD {
		int modnext(
		    int modid
		);
	}
301	AUE_NULL	STD {
		int modstat(
		    int modid,
		    _Out_ _Contains_long_ struct module_stat *stat
		);
	}
302	AUE_NULL	STD {
		int modfnext(
		    int modid
		);
	}
303	AUE_NULL	STD {
		int modfind(
		    _In_z_ const char *name
		);
	}
304	AUE_MODLOAD	STD {
		int kldload(
		    _In_z_ const char *file
		);
	}
305	AUE_MODUNLOAD	STD {
		int kldunload(
		    int fileid
		);
	}
306	AUE_NULL	STD {
		int kldfind(
		    _In_z_ const char *file
		);
	}
307	AUE_NULL	STD {
		int kldnext(
		    int fileid
		);
	}
308	AUE_NULL	STD {
		int kldstat(
		    int fileid,
		    _Out_ _Contains_long_ptr_ struct kld_file_stat *stat
		);
	}
309	AUE_NULL	STD {
		int kldfirstmod(
		    int fileid
		);
	}
310	AUE_GETSID	STD|CAPENABLED {
		int getsid(
		    pid_t pid
		);
	}
311	AUE_SETRESUID	STD|CAPENABLED {
		int setresuid(
		    uid_t ruid,
		    uid_t euid,
		    uid_t suid
		);
	}
312	AUE_SETRESGID	STD|CAPENABLED {
		int setresgid(
		    gid_t rgid,
		    gid_t egid,
		    gid_t sgid
		);
	}
313	AUE_NULL	OBSOL	signanosleep
314	AUE_AIO_RETURN	STD|CAPENABLED {
		ssize_t aio_return(
		    _Inout_ _Contains_long_ptr_ struct aiocb *aiocbp
		);
	}
315	AUE_AIO_SUSPEND	STD|CAPENABLED {
		int aio_suspend(
		    _Inout_updates_(nent) _Contains_long_ptr_ struct aiocb * const * aiocbp,
		    int nent,
		    _In_opt_ _Contains_long_timet_ const struct timespec *timeout
		);
	}
316	AUE_AIO_CANCEL	STD|CAPENABLED {
		int aio_cancel(
		    int fd,
		    _In_opt_ _Contains_long_ptr_ struct aiocb *aiocbp
		);
	}
317	AUE_AIO_ERROR	STD|CAPENABLED {
		int aio_error(
		    _In_ _Contains_long_ptr_ struct aiocb *aiocbp
		);
	}
318	AUE_AIO_READ	COMPAT6|CAPENABLED {
		int aio_read(
		    _Inout_ _Contains_long_ptr_ struct oaiocb *aiocbp
		);
	}
319	AUE_AIO_WRITE	COMPAT6|CAPENABLED {
		int aio_write(
		    _Inout_ _Contains_long_ptr_ struct oaiocb *aiocbp
		);
	}
320	AUE_LIO_LISTIO	COMPAT6|CAPENABLED {
		int lio_listio(
		    int mode,
		    _Inout_updates_(nent) _Contains_long_ptr_ struct oaiocb * const *acb_list,
		    int nent,
		    _In_opt_ _Contains_ptr_ struct osigevent *sig
		);
	}
321	AUE_NULL	STD|CAPENABLED {
		int yield(void);
	}
322	AUE_NULL	OBSOL	thr_sleep
323	AUE_NULL	OBSOL	thr_wakeup
324	AUE_MLOCKALL	STD|CAPENABLED {
		int mlockall(
		    int how
		);
	}
325	AUE_MUNLOCKALL	STD|CAPENABLED {
		int munlockall(void);
	}
326	AUE_GETCWD	STD {
		int __getcwd(
		    _Out_writes_z_(buflen) char *buf,
		    size_t buflen
		);
	}
327	AUE_NULL	STD|CAPENABLED {
		int sched_setparam(
		    pid_t pid,
		    _In_ const struct sched_param *param
		);
	}
328	AUE_NULL	STD|CAPENABLED {
		int sched_getparam(
		    pid_t pid,
		    _Out_ struct sched_param *param
		);
	}
329	AUE_NULL	STD|CAPENABLED {
		int sched_setscheduler(
		    pid_t pid,
		    int policy,
		    _In_ const struct sched_param *param
		);
	}
330	AUE_NULL	STD|CAPENABLED {
		int sched_getscheduler(
		    pid_t pid
		);
	}
331	AUE_NULL	STD|CAPENABLED {
		int sched_yield(void);
	}
332	AUE_NULL	STD|CAPENABLED {
		int sched_get_priority_max(
		    int policy
		);
	}
333	AUE_NULL	STD|CAPENABLED {
		int sched_get_priority_min(
		    int policy
		);
	}
334	AUE_NULL	STD|CAPENABLED {
		int sched_rr_get_interval(
		    pid_t pid,
		    _Out_ _Contains_long_timet_ struct timespec *interval
		);
	}
335	AUE_NULL	STD|CAPENABLED {
		int utrace(
		    _In_reads_bytes_(len) const void *addr,
		    size_t len
		);
	}
336	AUE_SENDFILE	COMPAT4|CAPENABLED {
		int sendfile(
		    int fd,
		    int s,
		    off_t offset,
		    size_t nbytes,
		    _In_opt_ _Contains_ptr_ struct sf_hdtr *hdtr,
		    _Out_opt_ off_t *sbytes,
		    int flags
		);
	}
337	AUE_NULL	STD {
		int kldsym(
		    int fileid,
		    int cmd,
		    _In_ _Contains_long_ptr_ void *data
		);
	}
338	AUE_JAIL	STD {
		int jail(
		    _In_ _Contains_ptr_ struct jail *jail
		);
	}
339	AUE_NULL	NOSTD|NOTSTATIC {
		int nnpfs_syscall(
		    int operation,
		    char *a_pathP,
		    int a_opcode,
		    void *a_paramsP,
		    int a_followSymlinks
		);
	}
340	AUE_SIGPROCMASK	STD|CAPENABLED {
		int sigprocmask(
		    int how,
		    _In_opt_ const sigset_t *set,
		    _Out_opt_ sigset_t *oset
		);
	}
341	AUE_SIGSUSPEND	STD|CAPENABLED {
		int sigsuspend(
		    _In_ const sigset_t *sigmask
		);
	}
342	AUE_SIGACTION	COMPAT4|CAPENABLED {
		int sigaction(
		    int sig,
		    _In_opt_ _Contains_ptr_ const struct sigaction *act,
		    _Out_opt_ _Contains_ptr_ struct sigaction *oact
		);
	}
343	AUE_SIGPENDING	STD|CAPENABLED {
		int sigpending(
		    _In_ sigset_t *set
		);
	}
344	AUE_SIGRETURN	COMPAT4|CAPENABLED {
		int sigreturn(
		    _In_ _Contains_long_ptr_ const struct freebsd4_ucontext *sigcntxp
		);
	}
345	AUE_SIGWAIT	STD|CAPENABLED {
		int sigtimedwait(
		    _In_ const sigset_t *set,
		    _Out_opt_ _Contains_long_ptr_ struct siginfo *info,
		    _In_opt_ _Contains_long_timet_ const struct timespec *timeout
		);
	}
346	AUE_NULL	STD|CAPENABLED {
		int sigwaitinfo(
		    _In_ const sigset_t *set,
		    _Out_opt_ _Contains_long_ptr_ struct siginfo *info
		);
	}
347	AUE_ACL_GET_FILE	STD {
		int __acl_get_file(
		    _In_z_ const char *path,
		    acl_type_t type,
		    _Out_ struct acl *aclp
		);
	}
348	AUE_ACL_SET_FILE	STD {
		int __acl_set_file(
		    _In_z_ const char *path,
		    acl_type_t type,
		    _In_ struct acl *aclp
		);
	}
349	AUE_ACL_GET_FD	STD|CAPENABLED {
		int __acl_get_fd(
		    int filedes,
		    acl_type_t type,
		    _Out_ struct acl *aclp
		);
	}
350	AUE_ACL_SET_FD	STD|CAPENABLED {
		int __acl_set_fd(
		    int filedes,
		    acl_type_t type,
		    _In_ struct acl *aclp
		);
	}
351	AUE_ACL_DELETE_FILE	STD {
		int __acl_delete_file(
		    _In_z_ const char *path,
		    acl_type_t type
		);
	}
352	AUE_ACL_DELETE_FD	STD|CAPENABLED {
		int __acl_delete_fd(
		    int filedes,
		    acl_type_t type
		);
	}
353	AUE_ACL_CHECK_FILE	STD {
		int __acl_aclcheck_file(
		    _In_z_ const char *path,
		    acl_type_t type,
		    _In_ struct acl *aclp
		);
	}
354	AUE_ACL_CHECK_FD	STD|CAPENABLED {
		int __acl_aclcheck_fd(
		    int filedes,
		    acl_type_t type,
		    _In_ struct acl *aclp
		);
	}
355	AUE_EXTATTRCTL	STD {
		int extattrctl(
		    _In_z_ const char *path,
		    int cmd,
		    _In_z_opt_ const char *filename,
		    int attrnamespace,
		    _In_z_ const char *attrname
		);
	}
356	AUE_EXTATTR_SET_FILE	STD {
		ssize_t extattr_set_file(
		    _In_z_ const char *path,
		    int attrnamespace,
		    _In_z_ const char *attrname,
		    _In_reads_bytes_(nbytes) void *data,
		    size_t nbytes
		);
	}
357	AUE_EXTATTR_GET_FILE	STD {
		ssize_t extattr_get_file(
		    _In_z_ const char *path,
		    int attrnamespace,
		    _In_z_ const char *attrname,
		    _Out_writes_bytes_(nbytes) void *data,
		    size_t nbytes
		);
	}
358	AUE_EXTATTR_DELETE_FILE	STD {
		int extattr_delete_file(
		    _In_z_ const char *path,
		    int attrnamespace,
		    _In_z_ const char *attrname
		);
	}
359	AUE_AIO_WAITCOMPLETE	STD|CAPENABLED {
		ssize_t aio_waitcomplete(
		    _Outptr_result_maybenull_ struct aiocb **aiocbp,
		    _In_opt_ _Contains_long_timet_ struct timespec *timeout
		);
	}
360	AUE_GETRESUID	STD|CAPENABLED {
		int getresuid(
		    _Out_opt_ uid_t *ruid,
		    _Out_opt_ uid_t *euid,
		    _Out_opt_ uid_t *suid
		);
	}
361	AUE_GETRESGID	STD|CAPENABLED {
		int getresgid(
		    _Out_opt_ gid_t *rgid,
		    _Out_opt_ gid_t *egid,
		    _Out_opt_ gid_t *sgid
		);
	}
362	AUE_KQUEUE	STD|CAPENABLED {
		int kqueue(void);
	}
363	AUE_KEVENT	COMPAT11|CAPENABLED {
		int kevent(
		    int fd,
		    _In_reads_opt_(nchanges) _Contains_ptr_ const struct freebsd11_kevent *changelist,
		    int nchanges,
		    _Out_writes_opt_(nevents) _Contains_ptr_ struct freebsd11_kevent *eventlist,
		    int nevents,
		    _In_opt_ _Contains_long_timet_ const struct timespec *timeout
		);
	}
364	AUE_NULL	OBSOL	__cap_get_proc
365	AUE_NULL	OBSOL	__cap_set_proc
366	AUE_NULL	OBSOL	__cap_get_fd
367	AUE_NULL	OBSOL	__cap_get_file
368	AUE_NULL	OBSOL	__cap_set_fd
369	AUE_NULL	OBSOL	__cap_set_file
370	AUE_NULL	RESERVED
371	AUE_EXTATTR_SET_FD	STD|CAPENABLED {
		ssize_t extattr_set_fd(
		    int fd,
		    int attrnamespace,
		    _In_z_ const char *attrname,
		    _In_reads_bytes_(nbytes) void *data,
		    size_t nbytes
		);
	}
372	AUE_EXTATTR_GET_FD	STD|CAPENABLED {
		ssize_t extattr_get_fd(
		    int fd,
		    int attrnamespace,
		    _In_z_ const char *attrname,
		    _Out_writes_bytes_(nbytes) void *data,
		    size_t nbytes
		);
	}
373	AUE_EXTATTR_DELETE_FD	STD|CAPENABLED {
		int extattr_delete_fd(
		    int fd,
		    int attrnamespace,
		    _In_z_ const char *attrname
		);
	}
374	AUE_SETUGID	STD {
		int __setugid(
		    int flag
		);
	}
375	AUE_NULL	OBSOL	nfsclnt
376	AUE_EACCESS	STD {
		int eaccess(
		    _In_z_ const char *path,
		    int amode
		);
	}
377	AUE_NULL	NOSTD|NOTSTATIC {
		int afs3_syscall(
		    long syscall,
		    long parm1,
		    long parm2,
		    long parm3,
		    long parm4,
		    long parm5,
		    long parm6
		);
	}
378	AUE_NMOUNT	STD {
		int nmount(
		    _In_reads_(iovcnt) _Contains_long_ptr_ struct iovec *iovp,
		    unsigned int iovcnt,
		    int flags
		);
	}
379	AUE_NULL	OBSOL	kse_exit
380	AUE_NULL	OBSOL	kse_wakeup
381	AUE_NULL	OBSOL	kse_create
382	AUE_NULL	OBSOL	kse_thr_interrupt
383	AUE_NULL	OBSOL	kse_release
384	AUE_NULL	STD|CAPENABLED {
		int __mac_get_proc(
		    _In_ _Contains_long_ptr_ struct mac *mac_p
		);
	}
385	AUE_NULL	STD|CAPENABLED {
		int __mac_set_proc(
		    _In_ _Contains_long_ptr_ struct mac *mac_p
		);
	}
386	AUE_NULL	STD|CAPENABLED {
		int __mac_get_fd(
		    int fd,
		    _In_ _Contains_long_ptr_ struct mac *mac_p
		);
	}
387	AUE_NULL	STD {
		int __mac_get_file(
		    _In_z_ const char *path_p,
		    _In_ _Contains_long_ptr_ struct mac *mac_p
		);
	}
388	AUE_NULL	STD|CAPENABLED {
		int __mac_set_fd(
		    int fd,
		    _In_ _Contains_long_ptr_ struct mac *mac_p
		);
	}
389	AUE_NULL	STD {
		int __mac_set_file(
		    _In_z_ const char *path_p,
		    _In_ _Contains_long_ptr_ struct mac *mac_p
		);
	}
390	AUE_NULL	STD {
		int kenv(
		    int what,
		    _In_z_opt_ const char *name,
		    _Inout_updates_opt_(len) char *value,
		    int len
		);
	}
391	AUE_LCHFLAGS	STD {
		int lchflags(
		    _In_z_ const char *path,
		    u_long flags
		);
	}
392	AUE_NULL	STD|CAPENABLED {
		int uuidgen(
		    _Out_writes_(count) struct uuid *store,
		    int count
		);
	}
393	AUE_SENDFILE	STD|CAPENABLED {
		int sendfile(
		    int fd,
		    int s,
		    off_t offset,
		    size_t nbytes,
		    _In_opt_ _Contains_ptr_ struct sf_hdtr *hdtr,
		    _Out_opt_ off_t *sbytes,
		    int flags
		);
	}
394	AUE_NULL	STD {
		int mac_syscall(
		    _In_z_ const char *policy,
		    int call,
		    _In_opt_ void *arg
		);
	}
395	AUE_GETFSSTAT	COMPAT11 {
		int getfsstat(
		    _Out_writes_bytes_opt_(bufsize) struct freebsd11_statfs *buf,
		    long bufsize,
		    int mode
		);
	}
396	AUE_STATFS	COMPAT11 {
		int statfs(
		    _In_z_ const char *path,
		    _Out_ struct freebsd11_statfs *buf
		);
	}
397	AUE_FSTATFS	COMPAT11|CAPENABLED {
		int fstatfs(
		    int fd,
		    _Out_ struct freebsd11_statfs *buf
		);
	}
398	AUE_FHSTATFS	COMPAT11 {
		int fhstatfs(
		    _In_ const struct fhandle *u_fhp,
		    _Out_ struct freebsd11_statfs *buf
		);
	}
399	AUE_NULL	RESERVED
400	AUE_SEMCLOSE	NOSTD {
		int ksem_close(
		    semid_t id
		);
	}
401	AUE_SEMPOST	NOSTD {
		int ksem_post(
		    semid_t id
		);
	}
402	AUE_SEMWAIT	NOSTD {
		int ksem_wait(
		    semid_t id
		);
	}
403	AUE_SEMTRYWAIT	NOSTD {
		int ksem_trywait(
		    semid_t id
		);
	}
404	AUE_SEMINIT	NOSTD {
		int ksem_init(
		    _Out_ semid_t *idp,
		    unsigned int value
		);
	}
405	AUE_SEMOPEN	NOSTD {
		int ksem_open(
		    _Out_ semid_t *idp,
		    _In_z_ const char *name,
		    int oflag,
		    mode_t mode,
		    unsigned int value
		);
	}
406	AUE_SEMUNLINK	NOSTD {
		int ksem_unlink(
		    _In_z_ const char *name
		);
	}
407	AUE_SEMGETVALUE	NOSTD {
		int ksem_getvalue(
		    semid_t id,
		    _Out_ int *val
		);
	}
408	AUE_SEMDESTROY	NOSTD {
		int ksem_destroy(
		    semid_t id
		);
	}
409	AUE_NULL	STD {
		int __mac_get_pid(
		    pid_t pid,
		    _In_ _Contains_long_ptr_ struct mac *mac_p
		);
	}
410	AUE_NULL	STD {
		int __mac_get_link(
		    _In_z_ const char *path_p,
		    _In_ _Contains_long_ptr_ struct mac *mac_p
		);
	}
411	AUE_NULL	STD {
		int __mac_set_link(
		    _In_z_ const char *path_p,
		    _In_ _Contains_long_ptr_ struct mac *mac_p
		);
	}
412	AUE_EXTATTR_SET_LINK	STD {
		ssize_t extattr_set_link(
		    _In_z_ const char *path,
		    int attrnamespace,
		    _In_z_ const char *attrname,
		    _In_reads_bytes_(nbytes) void *data,
		    size_t nbytes
		);
	}
413	AUE_EXTATTR_GET_LINK	STD {
		ssize_t extattr_get_link(
		    _In_z_ const char *path,
		    int attrnamespace,
		    _In_z_ const char *attrname,
		    _Out_writes_bytes_(nbytes) void *data,
		    size_t nbytes
		);
	}
414	AUE_EXTATTR_DELETE_LINK	STD {
		int extattr_delete_link(
		    _In_z_ const char *path,
		    int attrnamespace,
		    _In_z_ const char *attrname
		);
	}
415	AUE_NULL	STD {
		int __mac_execve(
		    _In_z_ const char *fname,
		    _In_ char **argv,
		    _In_ char **envv,
		    _In_ _Contains_long_ptr_ struct mac *mac_p
		);
	}
416	AUE_SIGACTION	STD|CAPENABLED {
		int sigaction(
		    int sig,
		    _In_opt_ _Contains_ptr_ const struct sigaction *act,
		    _Out_opt_ _Contains_ptr_ struct sigaction *oact
		);
	}
417	AUE_SIGRETURN	STD|CAPENABLED {
		int sigreturn(
		    _In_ _Contains_long_ptr_ const struct __ucontext *sigcntxp
		);
	}
418-420	AUE_NULL	RESERVED
421	AUE_NULL	STD|CAPENABLED {
		int getcontext(
		    _Out_ _Contains_long_ptr_ struct __ucontext *ucp
		);
	}
422	AUE_NULL	STD|CAPENABLED {
		int setcontext(
		    _In_ _Contains_long_ptr_ const struct __ucontext *ucp
		);
	}
423	AUE_NULL	STD {
		int swapcontext(
		    _Out_ _Contains_long_ptr_ struct __ucontext *oucp,
		    _In_ _Contains_long_ptr_ const struct __ucontext *ucp
		);
	}
424	AUE_SWAPOFF	COMPAT13 {
		int swapoff(
		    _In_z_ const char *name
		);
	}
425	AUE_ACL_GET_LINK	STD {
		int __acl_get_link(
		    _In_z_ const char *path,
		    acl_type_t type,
		    _Out_ struct acl *aclp
		);
	}
426	AUE_ACL_SET_LINK	STD {
		int __acl_set_link(
		    _In_z_ const char *path,
		    acl_type_t type,
		    _In_ struct acl *aclp
		);
	}
427	AUE_ACL_DELETE_LINK	STD {
		int __acl_delete_link(
		    _In_z_ const char *path,
		    acl_type_t type
		);
	}
428	AUE_ACL_CHECK_LINK	STD {
		int __acl_aclcheck_link(
		    _In_z_ const char *path,
		    acl_type_t type,
		    _In_ struct acl *aclp
		);
	}
429	AUE_SIGWAIT	STD|CAPENABLED {
		int sigwait(
		    _In_ const sigset_t *set,
		    _Out_ int *sig
		);
	}
430	AUE_THR_CREATE	STD|CAPENABLED {
		int thr_create(
		    _In_ _Contains_long_ptr_ ucontext_t *ctx,
		    _Out_ long *id,
		    int flags
		);
	}
431	AUE_THR_EXIT	STD|CAPENABLED {
		void thr_exit(
		    _Out_opt_ long *state
		);
	}
432	AUE_NULL	STD|CAPENABLED {
		int thr_self(
		    _Out_ long *id
		);
	}
433	AUE_THR_KILL	STD|CAPENABLED {
		int thr_kill(
		    long id,
		    int sig
		);
	}

434	AUE_NULL	COMPAT10 {
		int _umtx_lock(
		    _Inout_ struct umtx *umtx
		);
	}

435	AUE_NULL	COMPAT10 {
		int _umtx_unlock(
		    _Inout_ struct umtx *umtx
		);
	}

436	AUE_JAIL_ATTACH	STD {
		int jail_attach(
		    int jid
		);
	}
437	AUE_EXTATTR_LIST_FD	STD|CAPENABLED {
		ssize_t extattr_list_fd(
		    int fd,
		    int attrnamespace,
		    _Out_writes_bytes_opt_(nbytes) void *data,
		    size_t nbytes
		);
	}
438	AUE_EXTATTR_LIST_FILE	STD {
		ssize_t extattr_list_file(
		    _In_z_ const char *path,
		    int attrnamespace,
		    _Out_writes_bytes_opt_(nbytes) void *data,
		    size_t nbytes
		);
	}
439	AUE_EXTATTR_LIST_LINK	STD {
		ssize_t extattr_list_link(
		    _In_z_ const char *path,
		    int attrnamespace,
		    _Out_writes_bytes_opt_(nbytes) void *data,
		    size_t nbytes
		);
	}
440	AUE_NULL	OBSOL	kse_switchin
441	AUE_SEMWAIT	NOSTD {
		int ksem_timedwait(
		    semid_t id,
		    _In_opt_ _Contains_long_timet_ const struct timespec *abstime
		);
	}
442	AUE_NULL	STD|CAPENABLED {
		int thr_suspend(
		    _In_opt_ _Contains_long_timet_ const struct timespec *timeout
		);
	}
443	AUE_NULL	STD|CAPENABLED {
		int thr_wake(
		    long id
		);
	}
444	AUE_MODUNLOAD	STD {
		int kldunloadf(
		    int fileid,
		    int flags
		);
	}
445	AUE_AUDIT	STD {
		int audit(
		    _In_reads_bytes_(length) const void *record,
		    u_int length
		);
	}
446	AUE_AUDITON	STD {
		int auditon(
		    int cmd,
		    _In_opt_ void *data,
		    u_int length
		);
	}
447	AUE_GETAUID	STD|CAPENABLED {
		int getauid(
		    _Out_ uid_t *auid
		);
	}
448	AUE_SETAUID	STD|CAPENABLED {
		int setauid(
		    _In_ uid_t *auid
		);
	}
449	AUE_GETAUDIT	STD|CAPENABLED {
		int getaudit(
		    _Out_ struct auditinfo *auditinfo
		);
	}
450	AUE_SETAUDIT	STD|CAPENABLED {
		int setaudit(
		    _In_ struct auditinfo *auditinfo
		);
	}
451	AUE_GETAUDIT_ADDR	STD|CAPENABLED {
		int getaudit_addr(
		    _Out_writes_bytes_(length) struct auditinfo_addr *auditinfo_addr,
		    u_int length
		);
	}
452	AUE_SETAUDIT_ADDR	STD|CAPENABLED {
		int setaudit_addr(
		    _In_reads_bytes_(length) struct auditinfo_addr *auditinfo_addr,
		    u_int length
		);
	}
453	AUE_AUDITCTL	STD {
		int auditctl(
		    _In_z_ const char *path
		);
	}
454	AUE_NULL	STD|CAPENABLED {
		int _umtx_op(
		    _Inout_ void *obj,
		    int op,
		    u_long val,
		    _In_ void *uaddr1,
		    _In_ void *uaddr2
		);
	}
455	AUE_THR_NEW	STD|CAPENABLED {
		int thr_new(
		    _In_ _Contains_long_ptr_ struct thr_param *param,
		    int param_size
		);
	}
456	AUE_NULL	STD|CAPENABLED {
		int sigqueue(
		    pid_t pid,
		    int signum,
		    _In_ void *value
		);
	}

457	AUE_MQ_OPEN	NOSTD {
		int kmq_open(
		    _In_z_ const char *path,
		    int flags,
		    mode_t mode,
		    _In_opt_ _Contains_long_ const struct mq_attr *attr
		);
	}
458	AUE_MQ_SETATTR	NOSTD|CAPENABLED {
		int kmq_setattr(
		    int mqd,
		    _In_opt_ _Contains_long_ const struct mq_attr *attr,
		    _Out_opt_ _Contains_long_ struct mq_attr *oattr
		);
	}
459	AUE_MQ_TIMEDRECEIVE	NOSTD|CAPENABLED {
		int kmq_timedreceive(
		    int mqd,
		    _Out_writes_bytes_(msg_len) char *msg_ptr,
		    size_t msg_len,
		    _Out_opt_ unsigned *msg_prio,
		    _In_opt_ _Contains_long_timet_ const struct timespec *abs_timeout
		);
	}
460	AUE_MQ_TIMEDSEND	NOSTD|CAPENABLED {
		int kmq_timedsend(
		    int mqd,
		    _In_reads_bytes_(msg_len) const char *msg_ptr,
		    size_t msg_len,
		    unsigned msg_prio,
		    _In_opt_ _Contains_long_timet_ const struct timespec *abs_timeout
		);
	}
461	AUE_MQ_NOTIFY	NOSTD|CAPENABLED {
		int kmq_notify(
		    int mqd,
		    _In_opt_ _Contains_long_ptr_ const struct sigevent *sigev
		);
	}
462	AUE_MQ_UNLINK	NOSTD {
		int kmq_unlink(
		    _In_z_ const char *path
		);
	}
463	AUE_NULL	STD|CAPENABLED {
		void abort2(
		    _In_z_ const char *why,
		    int nargs,
		    _In_reads_(nargs) void **args
		);
	}
464	AUE_NULL	STD|CAPENABLED {
		int thr_set_name(
		    long id,
		    _In_z_ const char *name
		);
	}
465	AUE_AIO_FSYNC	STD|CAPENABLED {
		int aio_fsync(
		    int op,
		    _In_ _Contains_long_ptr_ struct aiocb *aiocbp
		);
	}
466	AUE_RTPRIO	STD|CAPENABLED {
		int rtprio_thread(
		    int function,
		    lwpid_t lwpid,
		    _Inout_ struct rtprio *rtp
		);
	}
467-470	AUE_NULL	RESERVED
471	AUE_SCTP_PEELOFF	NOSTD|CAPENABLED {
		int sctp_peeloff(
		    int sd,
		    uint32_t name
		);
	}
472	AUE_SCTP_GENERIC_SENDMSG	NOSTD|CAPENABLED {
		int sctp_generic_sendmsg(
		    int sd,
		    _In_reads_bytes_(mlen) void *msg,
		    int mlen,
		    _In_reads_bytes_(tolen) const struct sockaddr *to,
		    __socklen_t tolen,
		    _In_opt_ struct sctp_sndrcvinfo *sinfo,
		    int flags
		);
	}
473	AUE_SCTP_GENERIC_SENDMSG_IOV	NOSTD|CAPENABLED {
		int sctp_generic_sendmsg_iov(
		    int sd,
		    _In_reads_(iovlen) _Contains_long_ptr_ struct iovec *iov,
		    int iovlen,
		    _In_reads_bytes_(tolen) const struct sockaddr *to,
		    __socklen_t tolen,
		    _In_opt_ struct sctp_sndrcvinfo *sinfo,
		    int flags
		);
	}
474	AUE_SCTP_GENERIC_RECVMSG	NOSTD|CAPENABLED {
		int sctp_generic_recvmsg(
		    int sd,
		    _In_reads_(iovlen) _Contains_long_ptr_ struct iovec *iov,
		    int iovlen,
		    _Out_writes_bytes_(*fromlenaddr) struct sockaddr *from,
		    _Out_ __socklen_t *fromlenaddr,
		    _In_opt_ struct sctp_sndrcvinfo *sinfo,
		    _Out_opt_ int *msg_flags
		);
	}
475	AUE_PREAD	STD|CAPENABLED {
		ssize_t pread(
		    int fd,
		    _Out_writes_bytes_(nbyte) void *buf,
		    size_t nbyte,
		    off_t offset
		);
	}
476	AUE_PWRITE	STD|CAPENABLED {
		ssize_t pwrite(
		    int fd,
		    _In_reads_bytes_(nbyte) const void *buf,
		    size_t nbyte,
		    off_t offset
		);
	}
477	AUE_MMAP	STD|CAPENABLED {
		void *mmap(
		    _In_ void *addr,
		    size_t len,
		    int prot,
		    int flags,
		    int fd,
		    off_t pos
		);
	}
478	AUE_LSEEK	STD|CAPENABLED {
		off_t lseek(
		    int fd,
		    off_t offset,
		    int whence
		);
	}
479	AUE_TRUNCATE	STD {
		int truncate(
		    _In_z_ const char *path,
		    off_t length
		);
	}
480	AUE_FTRUNCATE	STD|CAPENABLED {
		int ftruncate(
		    int fd,
		    off_t length
		);
	}
481	AUE_THR_KILL2	STD {
		int thr_kill2(
		    pid_t pid,
		    long id,
		    int sig
		);
	}
482	AUE_SHMOPEN	COMPAT12|CAPENABLED {
		int shm_open(
		    _In_z_ const char *path,
		    int flags,
		    mode_t mode
		);
	}
483	AUE_SHMUNLINK	STD {
		int shm_unlink(
		    _In_z_ const char *path
		);
	}
484	AUE_NULL	STD {
		int cpuset(
		    _Out_ cpusetid_t *setid
		);
	}
485	AUE_NULL	STD {
		int cpuset_setid(
		    cpuwhich_t which,
		    id_t id,
		    cpusetid_t setid
		);
	}
486	AUE_NULL	STD {
		int cpuset_getid(
		    cpulevel_t level,
		    cpuwhich_t which,
		    id_t id,
		    _Out_ cpusetid_t *setid
		);
	}
487	AUE_NULL	STD|CAPENABLED {
		int cpuset_getaffinity(
		    cpulevel_t level,
		    cpuwhich_t which,
		    id_t id,
		    size_t cpusetsize,
		    _Out_ cpuset_t *mask
		);
	}
488	AUE_NULL	STD|CAPENABLED {
		int cpuset_setaffinity(
		    cpulevel_t level,
		    cpuwhich_t which,
		    id_t id,
		    size_t cpusetsize,
		    _Out_ const cpuset_t *mask
		);
	}
489	AUE_FACCESSAT	STD|CAPENABLED {
		int faccessat(
		    int fd,
		    _In_z_ const char *path,
		    int amode,
		    int flag
		);
	}
490	AUE_FCHMODAT	STD|CAPENABLED {
		int fchmodat(
		    int fd,
		    _In_z_ const char *path,
		    mode_t mode,
		    int flag
		);
	}
491	AUE_FCHOWNAT	STD|CAPENABLED {
		int fchownat(
		    int fd,
		    _In_z_ const char *path,
		    uid_t uid,
		    gid_t gid,
		    int flag
		);
	}
492	AUE_FEXECVE	STD|CAPENABLED {
		int fexecve(
		    int fd,
		    _In_ char **argv,
		    _In_ char **envv
		);
	}
493	AUE_FSTATAT	COMPAT11|CAPENABLED {
		int fstatat(
		    int fd,
		    _In_z_ const char *path,
		    _Out_ _Contains_long_timet_ struct freebsd11_stat *buf,
		    int flag
		);
	}
494	AUE_FUTIMESAT	STD|CAPENABLED {
		int futimesat(
		    int fd,
		    _In_z_ const char *path,
		    _In_reads_(2) _Contains_long_timet_ const struct timeval *times
		);
	}
495	AUE_LINKAT	STD|CAPENABLED {
		int linkat(
		    int fd1,
		    _In_z_ const char *path1,
		    int fd2,
		    _In_z_ const char *path2,
		    int flag
		);
	}
496	AUE_MKDIRAT	STD|CAPENABLED {
		int mkdirat(
		    int fd,
		    _In_z_ const char *path,
		    mode_t mode
		);
	}
497	AUE_MKFIFOAT	STD|CAPENABLED {
		int mkfifoat(
		    int fd,
		    _In_z_ const char *path,
		    mode_t mode
		);
	}
498	AUE_MKNODAT	COMPAT11|CAPENABLED {
		int mknodat(
		    int fd,
		    _In_z_ const char *path,
		    mode_t mode,
		    uint32_t dev
		);
	}
; XXX: see the comment for open
499	AUE_OPENAT_RWTC	STD|CAPENABLED {
		int openat(
		    int fd,
		    _In_z_ const char *path,
		    int flag,
		    mode_t mode
		);
	}
500	AUE_READLINKAT	STD|CAPENABLED {
		ssize_t readlinkat(
		    int fd,
		    _In_z_ const char *path,
		    _Out_writes_bytes_(bufsize) char *buf,
		    size_t bufsize
		);
	}
501	AUE_RENAMEAT	STD|CAPENABLED {
		int renameat(
		    int oldfd,
		    _In_z_ const char *old,
		    int newfd,
		    _In_z_ const char *new
		);
	}
502	AUE_SYMLINKAT	STD|CAPENABLED {
		int symlinkat(
		    _In_z_ const char *path1,
		    int fd,
		    _In_z_ const char *path2
		);
	}
503	AUE_UNLINKAT	STD|CAPENABLED {
		int unlinkat(
		    int fd,
		    _In_z_ const char *path,
		    int flag
		);
	}
504	AUE_POSIX_OPENPT	STD {
		int posix_openpt(
		    int flags
		);
	}
; 505 is initialised by the kgssapi code, if present.
505	AUE_NULL	NOSTD {
		int gssd_syscall(
		    _In_z_ const char *path
		);
	}
506	AUE_JAIL_GET	STD {
		int jail_get(
		    _In_reads_(iovcnt) _Contains_long_ptr_ struct iovec *iovp,
		    unsigned int iovcnt,
		    int flags
		);
	}
507	AUE_JAIL_SET	STD {
		int jail_set(
		    _In_reads_(iovcnt) _Contains_long_ptr_ struct iovec *iovp,
		    unsigned int iovcnt,
		    int flags
		);
	}
508	AUE_JAIL_REMOVE	STD {
		int jail_remove(
		    int jid
		);
	}
509	AUE_CLOSEFROM	COMPAT12|CAPENABLED {
		int closefrom(
		    int lowfd
		);
	}
510	AUE_SEMCTL	NOSTD {
		int __semctl(
		    int semid,
		    int semnum,
		    int cmd,
		    _Inout_ _Contains_ptr_ union semun *arg
		);
	}
511	AUE_MSGCTL	NOSTD {
		int msgctl(
		    int msqid,
		    int cmd,
		    _Inout_opt_ _Contains_long_ptr_ struct msqid_ds *buf
		);
	}
512	AUE_SHMCTL	NOSTD {
		int shmctl(
		    int shmid,
		    int cmd,
		    _Inout_opt_ _Contains_long_ struct shmid_ds *buf
		);
	}
513	AUE_LPATHCONF	STD {
		int lpathconf(
		    _In_z_ const char *path,
		    int name
		);
	}
514	AUE_NULL	OBSOL	cap_new
515	AUE_CAP_RIGHTS_GET	STD|CAPENABLED {
		int __cap_rights_get(
		    int version,
		    int fd,
		    _Out_ cap_rights_t *rightsp
		);
	}
516	AUE_CAP_ENTER	STD|CAPENABLED {
		int cap_enter(void);
	}
517	AUE_CAP_GETMODE	STD|CAPENABLED {
		int cap_getmode(
		    _Out_ u_int *modep
		);
	}
518	AUE_PDFORK	STD|CAPENABLED {
		int pdfork(
		    _Out_ int *fdp,
		    int flags
		);
	}
519	AUE_PDKILL	STD|CAPENABLED {
		int pdkill(
		    int fd,
		    int signum
		);
	}
520	AUE_PDGETPID	STD|CAPENABLED {
		int pdgetpid(
		    int fd,
		    _Out_ pid_t *pidp
		);
	}
521	AUE_NULL	RESERVED
522	AUE_SELECT	STD|CAPENABLED {
		int pselect(
		    int nd,
		    _Inout_opt_ fd_set *in,
		    _Inout_opt_ fd_set *ou,
		    _Inout_opt_ fd_set *ex,
		    _In_opt_ _Contains_long_timet_ const struct timespec *ts,
		    _In_opt_ const sigset_t *sm
		);
	}
523	AUE_GETLOGINCLASS	STD|CAPENABLED {
		int getloginclass(
		    _Out_writes_z_(namelen) char *namebuf,
		    size_t namelen
		);
	}
524	AUE_SETLOGINCLASS	STD {
		int setloginclass(
		    _In_z_ const char *namebuf
		);
	}
525	AUE_NULL	STD {
		int rctl_get_racct(
		    _In_reads_bytes_(inbuflen) const void *inbufp,
		    size_t inbuflen,
		    _Out_writes_bytes_(outbuflen) void *outbufp,
		    size_t outbuflen
		);
	}
526	AUE_NULL	STD {
		int rctl_get_rules(
		    _In_reads_bytes_(inbuflen) const void *inbufp,
		    size_t inbuflen,
		    _Out_writes_bytes_(outbuflen) void *outbufp,
		    size_t outbuflen
		);
	}
527	AUE_NULL	STD {
		int rctl_get_limits(
		    _In_reads_bytes_(inbuflen) const void *inbufp,
		    size_t inbuflen,
		    _Out_writes_bytes_(outbuflen) void *outbufp,
		    size_t outbuflen
		);
	}
528	AUE_NULL	STD {
		int rctl_add_rule(
		    _In_reads_bytes_(inbuflen) const void *inbufp,
		    size_t inbuflen,
		    _Out_writes_bytes_(outbuflen) void *outbufp,
		    size_t outbuflen
		);
	}
529	AUE_NULL	STD {
		int rctl_remove_rule(
		    _In_reads_bytes_(inbuflen) const void *inbufp,
		    size_t inbuflen,
		    _Out_writes_bytes_(outbuflen) void *outbufp,
		    size_t outbuflen
		);
	}
530	AUE_POSIX_FALLOCATE	STD|CAPENABLED {
		int posix_fallocate(
		    int fd,
		    off_t offset,
		    off_t len
		);
	}
531	AUE_POSIX_FADVISE	STD|CAPENABLED {
		int posix_fadvise(
		    int fd,
		    off_t offset,
		    off_t len,
		    int advice
		);
	}
532	AUE_WAIT6	STD {
		int wait6(
		    idtype_t idtype,
		    id_t id,
		    _Out_opt_ int *status,
		    int options,
		    _Out_opt_ _Contains_long_ struct __wrusage *wrusage,
		    _Out_opt_ _Contains_long_ptr_ struct siginfo *info
		);
	}
533	AUE_CAP_RIGHTS_LIMIT	STD|CAPENABLED {
		int cap_rights_limit(
		    int fd,
		    _In_ cap_rights_t *rightsp
		);
	}
534	AUE_CAP_IOCTLS_LIMIT	STD|CAPENABLED {
		int cap_ioctls_limit(
		    int fd,
		    _In_reads_(ncmds) const u_long *cmds,
		    size_t ncmds
		);
	}
535	AUE_CAP_IOCTLS_GET	STD|CAPENABLED {
		ssize_t cap_ioctls_get(
		    int fd,
		    _Out_writes_(maxcmds) u_long *cmds,
		    size_t maxcmds
		);
	}
536	AUE_CAP_FCNTLS_LIMIT	STD|CAPENABLED {
		int cap_fcntls_limit(
		    int fd,
		    uint32_t fcntlrights
		);
	}
537	AUE_CAP_FCNTLS_GET	STD|CAPENABLED {
		int cap_fcntls_get(
		    int fd,
		    _Out_ uint32_t *fcntlrightsp
		);
	}
538	AUE_BINDAT	STD|CAPENABLED {
		int bindat(
		    int fd,
		    int s,
		    _In_reads_bytes_(namelen) const struct sockaddr *name,
		    __socklen_t namelen
		);
	}
539	AUE_CONNECTAT	STD|CAPENABLED {
		int connectat(
		    int fd,
		    int s,
		    _In_reads_bytes_(namelen) const struct sockaddr *name,
		    __socklen_t namelen
		);
	}
540	AUE_CHFLAGSAT	STD|CAPENABLED {
		int chflagsat(
		    int fd,
		    _In_z_ const char *path,
		    u_long flags,
		    int atflag
		);
	}
541	AUE_ACCEPT	STD|CAPENABLED {
		int accept4(
		    int s,
		    _Out_writes_bytes_opt_(*anamelen) struct sockaddr *name,
		    _Inout_opt_ __socklen_t *anamelen,
		    int flags
		);
	}
542	AUE_PIPE	STD|CAPENABLED {
		int pipe2(
		    _Out_writes_(2) int *fildes,
		    int flags
		);
	}
543	AUE_AIO_MLOCK	STD {
		int aio_mlock(
		    _In_ _Contains_long_ptr_ struct aiocb *aiocbp
		);
	}
544	AUE_PROCCTL	STD {
		int procctl(
		    idtype_t idtype,
		    id_t id,
		    int com,
		    _In_opt_ void *data
		);
	}
545	AUE_POLL	STD|CAPENABLED {
		int ppoll(
		    _Inout_updates_(nfds) struct pollfd *fds,
		    u_int nfds,
		    _In_opt_ _Contains_long_timet_ const struct timespec *ts,
		    _In_opt_ const sigset_t *set
		);
	}
546	AUE_FUTIMES	STD|CAPENABLED {
		int futimens(
		    int fd,
		    _In_reads_(2) _Contains_long_timet_ const struct timespec *times
		);
	}
547	AUE_FUTIMESAT	STD|CAPENABLED {
		int utimensat(
		    int fd,
		    _In_z_ const char *path,
		    _In_reads_(2) _Contains_long_timet_ const struct timespec *times,
		    int flag
		);
	}
548	AUE_NULL	OBSOL	numa_getaffinity
549	AUE_NULL	OBSOL	numa_setaffinity
550	AUE_FSYNC	STD|CAPENABLED {
		int fdatasync(
		    int fd
		);
	}
551	AUE_FSTAT	STD|CAPENABLED {
		int fstat(
		    int fd,
		    _Out_ _Contains_long_timet_ struct stat *sb
		);
	}
552	AUE_FSTATAT	STD|CAPENABLED {
		int fstatat(
		    int fd,
		    _In_z_ const char *path,
		    _Out_ _Contains_long_timet_ struct stat *buf,
		    int flag
		);
	}
553	AUE_FHSTAT	STD {
		int fhstat(
		    _In_ const struct fhandle *u_fhp,
		    _Out_ _Contains_long_timet_ struct stat *sb
		);
	}
554	AUE_GETDIRENTRIES STD|CAPENABLED {
		ssize_t getdirentries(
		    int fd,
		    _Out_writes_bytes_(count) char *buf,
		    size_t count,
		    _Out_opt_ off_t *basep
		);
	}
555	AUE_STATFS	STD {
		int statfs(
		    _In_z_ const char *path,
		    _Out_ struct statfs *buf
		);
	}
556	AUE_FSTATFS	STD|CAPENABLED {
		int fstatfs(
		    int fd,
		    _Out_ struct statfs *buf
		);
	}
557	AUE_GETFSSTAT	STD {
		int getfsstat(
		    _Out_writes_bytes_opt_(bufsize) struct statfs *buf,
		    long bufsize,
		    int mode
		);
	}
558	AUE_FHSTATFS	STD {
		int fhstatfs(
		    _In_ const struct fhandle *u_fhp,
		    _Out_ struct statfs *buf
		);
	}
559	AUE_MKNODAT	STD|CAPENABLED {
		int mknodat(
		    int fd,
		    _In_z_ const char *path,
		    mode_t mode,
		    dev_t dev
		);
	}
560	AUE_KEVENT	STD|CAPENABLED {
		int kevent(
		    int fd,
		    _In_reads_opt_(nchanges) _Contains_ptr_ const struct kevent *changelist,
		    int nchanges,
		    _Out_writes_opt_(nevents) _Contains_ptr_ struct kevent *eventlist,
		    int nevents,
		    _In_opt_ _Contains_long_timet_ const struct timespec *timeout
		);
	}
561	AUE_NULL	STD|CAPENABLED {
		int cpuset_getdomain(
		    cpulevel_t level,
		    cpuwhich_t which,
		    id_t id,
		    size_t domainsetsize,
		    _Out_writes_bytes_(domainsetsize) domainset_t *mask,
		    _Out_ int *policy
		);
	}
562	AUE_NULL	STD|CAPENABLED {
		int cpuset_setdomain(
		    cpulevel_t level,
		    cpuwhich_t which,
		    id_t id,
		    size_t domainsetsize,
		    _In_ domainset_t *mask,
		    int policy
		);
	}
563	AUE_NULL	STD|CAPENABLED {
		int getrandom(
		    _Out_writes_bytes_(buflen) void *buf,
		    size_t buflen,
		    unsigned int flags
		);
	}
564	AUE_NULL	STD {
		int getfhat(
		    int fd,
		    _In_z_ char *path,
		    _Out_ struct fhandle *fhp,
		    int flags
		);
	}
565	AUE_NULL	STD {
		int fhlink(
		    _In_ struct fhandle *fhp,
		    _In_z_ const char *to
		);
	}
566	AUE_NULL	STD {
		int fhlinkat(
		    _In_ struct fhandle *fhp,
		    int tofd,
		    _In_z_ const char *to,
		);
	}
567	AUE_NULL	STD {
		int fhreadlink(
		    _In_ struct fhandle *fhp,
		    _Out_writes_(bufsize) char *buf,
		    size_t bufsize
		);
	}
568	AUE_UNLINKAT	STD|CAPENABLED {
		int funlinkat(
		    int dfd,
		    _In_z_ const char *path,
		    int fd,
		    int flag
		);
	}
569	AUE_NULL	STD|CAPENABLED {
		ssize_t copy_file_range(
		    int infd,
		    _Inout_opt_ off_t *inoffp,
		    int outfd,
		    _Inout_opt_ off_t *outoffp,
		    size_t len,
		    unsigned int flags
		);
	}
570	AUE_SYSCTL	STD|CAPENABLED {
		int __sysctlbyname(
		    _In_reads_(namelen) const char *name,
		    size_t namelen,
		    _Out_writes_bytes_opt_(*oldlenp) void *old,
		    _Inout_opt_ size_t *oldlenp,
		    _In_reads_bytes_opt_(newlen) void *new,
		    size_t newlen
		);
	}
571	AUE_SHMOPEN	STD|CAPENABLED {
		int shm_open2(
		    _In_z_ const char *path,
		    int flags,
		    mode_t mode,
		    int shmflags,
		    _In_z_ const char *name
		);
	}
572	AUE_SHMRENAME	STD {
		int shm_rename(
		    _In_z_ const char *path_from,
		    _In_z_ const char *path_to,
		    int flags
		);
	}
573	AUE_NULL	STD|CAPENABLED {
		int sigfastblock(
		    int cmd,
		    _Inout_opt_ uint32_t *ptr
		);
	}
574	AUE_REALPATHAT	STD {
		int __realpathat(
		    int fd,
		    _In_z_ const char *path,
		    _Out_writes_z_(size) char *buf,
		    size_t size,
		    int flags
		);
	}
575	AUE_CLOSERANGE	STD|CAPENABLED {
		int close_range(
		    u_int lowfd,
		    u_int highfd,
		    int flags
		);
	}
; 576 is initialised by the krpc code, if present.
576	AUE_NULL	NOSTD {
		int rpctls_syscall(
		    int op,
		    _In_z_ const char *path
		);
	}
577	AUE_SPECIALFD	STD|CAPENABLED {
		int __specialfd(
		    int type,
		    _In_reads_bytes_(len) const void *req,
		    size_t len
		);
	}
578	AUE_AIO_WRITEV	STD|CAPENABLED {
		int aio_writev(
		    _Inout_ _Contains_long_ptr_ struct aiocb *aiocbp
		);
	}
579	AUE_AIO_READV	STD|CAPENABLED {
		int aio_readv(
		    _Inout_ _Contains_long_ptr_ struct aiocb *aiocbp
		);
	}
580	AUE_FSPACECTL	STD|CAPENABLED {
		int fspacectl(
		    int fd,
		    int cmd,
		    _In_ const struct spacectl_range *rqsr,
		    int flags,
		    _Out_opt_ struct spacectl_range *rmsr,
		);
	}
581	AUE_NULL	STD|CAPENABLED {
		int sched_getcpu(void);
	}
582	AUE_SWAPOFF	STD {
		int swapoff(
		    _In_z_ const char *name,
		    u_int flags,
		);
	}
583	AUE_KQUEUE	STD|CAPENABLED {
		int kqueuex(
		    u_int flags
		);
	}
584	AUE_NULL	STD|CAPENABLED {
		int membarrier(
		    int cmd,
		    unsigned flags,
		    int cpu_id
		);
	}
585	AUE_TIMERFD	STD|CAPENABLED {
		int timerfd_create(
		    int clockid,
		    int flags
		);
	}
586	AUE_TIMERFD	STD|CAPENABLED {
		int timerfd_gettime(
		    int fd,
		    _Out_ _Contains_long_timet_ struct itimerspec *curr_value
		);
	}
587	AUE_TIMERFD	STD|CAPENABLED {
		int timerfd_settime(
		    int fd,
		    int flags,
		    _In_ _Contains_long_timet_ const struct itimerspec *new_value,
		    _Out_opt_ _Contains_long_timet_ struct itimerspec *old_value
		);
	}


; vim: syntax=off