3317 lines
67 KiB
Plaintext
3317 lines
67 KiB
Plaintext
; 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)
|
|
; 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_ 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_ 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_ 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
|
|
);
|
|
}
|
|
|
|
; vim: syntax=off
|