Assign audit event identifiers to many system calls.

Much work by:	wsalamon
Obtained from:	TrustedBSD Project

1 files changed, 225 insertions, 226 deletions

diff --git a/sys/kern/syscalls.master b/sys/kern/syscalls.master
index f2974b7..aa84a00 100644
--- a/sys/kern/syscalls.master
+++ b/sys/kern/syscalls.master
@@ -51,246 +51,246 @@
 ; of the current calls.
 
 0	AUE_NULL	MSTD	{ int nosys(void); } syscall nosys_args int
-1	AUE_NULL	MSTD	{ void sys_exit(int rval); } exit \
+1	AUE_EXIT	MSTD	{ void sys_exit(int rval); } exit \
 				    sys_exit_args void
-2	AUE_NULL	MSTD	{ int fork(void); }
+2	AUE_FORK	MSTD	{ int fork(void); }
 3	AUE_NULL	MSTD	{ ssize_t read(int fd, void *buf, \
 				    size_t nbyte); }
 4	AUE_NULL	MSTD	{ ssize_t write(int fd, const void *buf, \
 				    size_t nbyte); }
-5	AUE_NULL	MSTD	{ int open(char *path, int flags, int mode); }
+5	AUE_OPEN_RWTC	MSTD	{ int open(char *path, int flags, int mode); }
 ; XXX should be		{ int open(const char *path, int flags, ...); }
 ; but we're not ready for `const' or varargs.
 ; XXX man page says `mode_t mode'.
-6	AUE_NULL	MSTD	{ int close(int fd); }
-7	AUE_NULL	MSTD	{ int wait4(int pid, int *status, \
+6	AUE_CLOSE	MSTD	{ int close(int fd); }
+7	AUE_WAIT4	MSTD	{ int wait4(int pid, int *status, \
 				    int options, struct rusage *rusage); } \
 				    wait4 wait_args int
-8	AUE_NULL	MCOMPAT	{ int creat(char *path, int mode); }
-9	AUE_NULL	MSTD	{ int link(char *path, char *link); }
-10	AUE_NULL	MSTD	{ int unlink(char *path); }
+8	AUE_O_CREAT	MCOMPAT	{ int creat(char *path, int mode); }
+9	AUE_LINK	MSTD	{ int link(char *path, char *link); }
+10	AUE_UNLINK	MSTD	{ int unlink(char *path); }
 11	AUE_NULL	OBSOL	execv
-12	AUE_NULL	MSTD	{ int chdir(char *path); }
-13	AUE_NULL	MSTD	{ int fchdir(int fd); }
-14	AUE_NULL	MSTD	{ int mknod(char *path, int mode, int dev); }
-15	AUE_NULL	MSTD	{ int chmod(char *path, int mode); }
-16	AUE_NULL	MSTD	{ int chown(char *path, int uid, int gid); }
+12	AUE_CHDIR	MSTD	{ int chdir(char *path); }
+13	AUE_FCHDIR	MSTD	{ int fchdir(int fd); }
+14	AUE_MKNOD	MSTD	{ int mknod(char *path, int mode, int dev); }
+15	AUE_CHMOD	MSTD	{ int chmod(char *path, int mode); }
+16	AUE_CHOWN	MSTD	{ int chown(char *path, int uid, int gid); }
 17	AUE_NULL	MSTD	{ int obreak(char *nsize); } break \
 				    obreak_args int
-18	AUE_NULL	MCOMPAT4	{ int getfsstat(struct ostatfs *buf, \
+18	AUE_GETFSSTAT	MCOMPAT4	{ int getfsstat(struct ostatfs *buf, \
 				    long bufsize, int flags); }
-19	AUE_NULL	MCOMPAT	{ long lseek(int fd, long offset, \
+19	AUE_LSEEK	MCOMPAT	{ long lseek(int fd, long offset, \
 				    int whence); }
-20	AUE_NULL	MSTD	{ pid_t getpid(void); }
-21	AUE_NULL	STD	{ int mount(char *type, char *path, \
+20	AUE_GETPID	MSTD	{ pid_t getpid(void); }
+21	AUE_MOUNT	STD	{ int mount(char *type, char *path, \
 				    int flags, caddr_t data); }
 ; XXX `path' should have type `const char *' but we're not ready for that.
-22	AUE_NULL	STD	{ int unmount(char *path, int flags); }
-23	AUE_NULL	MSTD	{ int setuid(uid_t uid); }
-24	AUE_NULL	MSTD	{ uid_t getuid(void); }
-25	AUE_NULL	MSTD	{ uid_t geteuid(void); }
-26	AUE_NULL	MSTD	{ int ptrace(int req, pid_t pid, \
+22	AUE_UMOUNT	STD	{ int unmount(char *path, int flags); }
+23	AUE_SETUID	MSTD	{ int setuid(uid_t uid); }
+24	AUE_GETUID	MSTD	{ uid_t getuid(void); }
+25	AUE_GETEUID	MSTD	{ uid_t geteuid(void); }
+26	AUE_PTRACE	MSTD	{ int ptrace(int req, pid_t pid, \
 				    caddr_t addr, int data); }
-27	AUE_NULL	MSTD	{ int recvmsg(int s, struct msghdr *msg, \
+27	AUE_RECVMSG	MSTD	{ int recvmsg(int s, struct msghdr *msg, \
 				    int flags); }
-28	AUE_NULL	MSTD	{ int sendmsg(int s, struct msghdr *msg, \
+28	AUE_SENDMSG	MSTD	{ int sendmsg(int s, struct msghdr *msg, \
 				    int flags); }
-29	AUE_NULL	MSTD	{ int recvfrom(int s, caddr_t buf, \
+29	AUE_RECVFROM	MSTD	{ int recvfrom(int s, caddr_t buf, \
 				    size_t len, int flags, \
 				    struct sockaddr * __restrict from, \
 				    __socklen_t * __restrict fromlenaddr); }
-30	AUE_NULL	MSTD	{ int accept(int s, \
+30	AUE_ACCEPT	MSTD	{ int accept(int s, \
 				    struct sockaddr * __restrict name, \
 				    __socklen_t * __restrict anamelen); }
-31	AUE_NULL	MSTD	{ int getpeername(int fdes, \
+31	AUE_GETPEERNAME	MSTD	{ int getpeername(int fdes, \
 				    struct sockaddr * __restrict asa, \
 				    __socklen_t * __restrict alen); }
-32	AUE_NULL	MSTD	{ int getsockname(int fdes, \
+32	AUE_GETSOCKNAME	MSTD	{ int getsockname(int fdes, \
 				    struct sockaddr * __restrict asa, \
 				    __socklen_t * __restrict alen); }
-33	AUE_NULL	MSTD	{ int access(char *path, int flags); }
-34	AUE_NULL	MSTD	{ int chflags(char *path, int flags); }
-35	AUE_NULL	MSTD	{ int fchflags(int fd, int flags); }
-36	AUE_NULL	MSTD	{ int sync(void); }
-37	AUE_NULL	MSTD	{ int kill(int pid, int signum); }
-38	AUE_NULL	MCOMPAT	{ int stat(char *path, struct ostat *ub); }
-39	AUE_NULL	MSTD	{ pid_t getppid(void); }
-40	AUE_NULL	MCOMPAT	{ int lstat(char *path, struct ostat *ub); }
-41	AUE_NULL	MSTD	{ int dup(u_int fd); }
-42	AUE_NULL	MSTD	{ int pipe(void); }
-43	AUE_NULL	MSTD	{ gid_t getegid(void); }
-44	AUE_NULL	MSTD	{ int profil(caddr_t samples, size_t size, \
+33	AUE_ACCESS	MSTD	{ int access(char *path, int flags); }
+34	AUE_CHFLAGS	MSTD	{ int chflags(char *path, int flags); }
+35	AUE_FCHFLAGS	MSTD	{ int fchflags(int fd, int flags); }
+36	AUE_SYNC	MSTD	{ int sync(void); }
+37	AUE_KILL	MSTD	{ int kill(int pid, int signum); }
+38	AUE_STAT	MCOMPAT	{ int stat(char *path, struct ostat *ub); }
+39	AUE_GETPPID	MSTD	{ pid_t getppid(void); }
+40	AUE_LSTAT	MCOMPAT	{ int lstat(char *path, struct ostat *ub); }
+41	AUE_DUP		MSTD	{ int dup(u_int fd); }
+42	AUE_PIPE	MSTD	{ int pipe(void); }
+43	AUE_GETEGID	MSTD	{ gid_t getegid(void); }
+44	AUE_PROFILE	MSTD	{ int profil(caddr_t samples, size_t size, \
 				    size_t offset, u_int scale); }
-45	AUE_NULL	MSTD	{ int ktrace(const char *fname, int ops, \
+45	AUE_KTRACE	MSTD	{ int ktrace(const char *fname, int ops, \
 				    int facs, int pid); }
-46	AUE_NULL	MCOMPAT	{ int sigaction(int signum, \
+46	AUE_SIGACTION	MCOMPAT	{ int sigaction(int signum, \
 				    struct osigaction *nsa, \
 				    struct osigaction *osa); }
-47	AUE_NULL	MSTD	{ gid_t getgid(void); }
-48	AUE_NULL	MCOMPAT	{ int sigprocmask(int how, osigset_t mask); }
+47	AUE_GETGID	MSTD	{ gid_t getgid(void); }
+48	AUE_SIGPROCMASK	MCOMPAT	{ 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_NULL	MSTD	{ int getlogin(char *namebuf, u_int \
+49	AUE_GETLOGIN	MSTD	{ int getlogin(char *namebuf, u_int \
 				    namelen); }
-50	AUE_NULL	MSTD	{ int setlogin(char *namebuf); }
-51	AUE_NULL	MSTD	{ int acct(char *path); }
-52	AUE_NULL	MCOMPAT	{ int sigpending(void); }
-53	AUE_NULL	MSTD	{ int sigaltstack(stack_t *ss, \
+50	AUE_SETLOGIN	MSTD	{ int setlogin(char *namebuf); }
+51	AUE_ACCT	MSTD	{ int acct(char *path); }
+52	AUE_SIGPENDING	MCOMPAT	{ int sigpending(void); }
+53	AUE_SIGPENDING	MSTD	{ int sigaltstack(stack_t *ss, \
 				    stack_t *oss); }
-54	AUE_NULL	MSTD	{ int ioctl(int fd, u_long com, \
+54	AUE_IOCTL	MSTD	{ int ioctl(int fd, u_long com, \
 				    caddr_t data); }
-55	AUE_NULL	MSTD	{ int reboot(int opt); }
-56	AUE_NULL	MSTD	{ int revoke(char *path); }
-57	AUE_NULL	MSTD	{ int symlink(char *path, char *link); }
-58	AUE_NULL	MSTD	{ int readlink(char *path, char *buf, \
+55	AUE_REBOOT	MSTD	{ int reboot(int opt); }
+56	AUE_REVOKE	MSTD	{ int revoke(char *path); }
+57	AUE_SYMLINK	MSTD	{ int symlink(char *path, char *link); }
+58	AUE_READLINK	MSTD	{ int readlink(char *path, char *buf, \
 				    int count); }
-59	AUE_NULL	MSTD	{ int execve(char *fname, char **argv, \
+59	AUE_EXECVE	MSTD	{ int execve(char *fname, char **argv, \
 				    char **envv); }
-60	AUE_NULL	MSTD	{ int umask(int newmask); } umask umask_args \
+60	AUE_UMASK	MSTD	{ int umask(int newmask); } umask umask_args \
 				    int
-61	AUE_NULL	MSTD	{ int chroot(char *path); }
-62	AUE_NULL	MCOMPAT	{ int fstat(int fd, struct ostat *sb); }
+61	AUE_CHROOT	MSTD	{ int chroot(char *path); }
+62	AUE_FSTAT	MCOMPAT	{ int fstat(int fd, struct ostat *sb); }
 63	AUE_NULL	MCOMPAT	{ int getkerninfo(int op, char *where, \
 				    size_t *size, int arg); } getkerninfo \
 				    getkerninfo_args int
-64	AUE_NULL	MCOMPAT	{ int getpagesize(void); } getpagesize \
+64	AUE_O_GETPAGESIZE	MCOMPAT	{ int getpagesize(void); } getpagesize \
 				    getpagesize_args int
-65	AUE_NULL	MSTD	{ int msync(void *addr, size_t len, \
+65	AUE_MSYNC	MSTD	{ int msync(void *addr, size_t len, \
 				    int flags); }
-66	AUE_NULL	MSTD	{ int vfork(void); }
+66	AUE_VFORK	MSTD	{ int vfork(void); }
 67	AUE_NULL	OBSOL	vread
 68	AUE_NULL	OBSOL	vwrite
-69	AUE_NULL	MSTD	{ int sbrk(int incr); }
-70	AUE_NULL	MSTD	{ int sstk(int incr); }
-71	AUE_NULL	MCOMPAT	{ int mmap(void *addr, int len, int prot, \
+69	AUE_SBRK	MSTD	{ int sbrk(int incr); }
+70	AUE_SSTK	MSTD	{ int sstk(int incr); }
+71	AUE_MMAP	MCOMPAT	{ int mmap(void *addr, int len, int prot, \
 				    int flags, int fd, long pos); }
-72	AUE_NULL	MSTD	{ int ovadvise(int anom); } vadvise \
+72	AUE_O_VADVISE	MSTD	{ int ovadvise(int anom); } vadvise \
 				    ovadvise_args int
-73	AUE_NULL	MSTD	{ int munmap(void *addr, size_t len); }
-74	AUE_NULL	MSTD	{ int mprotect(const void *addr, size_t len, \
+73	AUE_MUNMAP	MSTD	{ int munmap(void *addr, size_t len); }
+74	AUE_MPROTECT	MSTD	{ int mprotect(const void *addr, size_t len, \
 				    int prot); }
-75	AUE_NULL	MSTD	{ int madvise(void *addr, size_t len, \
+75	AUE_MADVISE	MSTD	{ int madvise(void *addr, size_t len, \
 				    int behav); }
 76	AUE_NULL	OBSOL	vhangup
 77	AUE_NULL	OBSOL	vlimit
-78	AUE_NULL	MSTD	{ int mincore(const void *addr, size_t len, \
+78	AUE_MINCORE	MSTD	{ int mincore(const void *addr, size_t len, \
 				    char *vec); }
-79	AUE_NULL	MSTD	{ int getgroups(u_int gidsetsize, \
+79	AUE_GETGROUPS	MSTD	{ int getgroups(u_int gidsetsize, \
 				    gid_t *gidset); }
-80	AUE_NULL	MSTD	{ int setgroups(u_int gidsetsize, \
+80	AUE_SETGROUPS	MSTD	{ int setgroups(u_int gidsetsize, \
 				    gid_t *gidset); }
-81	AUE_NULL	MSTD	{ int getpgrp(void); }
-82	AUE_NULL	MSTD	{ int setpgid(int pid, int pgid); }
-83	AUE_NULL	MSTD	{ int setitimer(u_int which, struct \
+81	AUE_GETPGRP	MSTD	{ int getpgrp(void); }
+82	AUE_SETPGRP	MSTD	{ int setpgid(int pid, int pgid); }
+83	AUE_SETITIMER	MSTD	{ int setitimer(u_int which, struct \
 				    itimerval *itv, struct itimerval *oitv); }
-84	AUE_NULL	MCOMPAT	{ int wait(void); }
-85	AUE_NULL	MSTD	{ int swapon(char *name); }
-86	AUE_NULL	MSTD	{ int getitimer(u_int which, \
+84	AUE_O_WAIT	MCOMPAT	{ int wait(void); }
+85	AUE_SWAPON	MSTD	{ int swapon(char *name); }
+86	AUE_GETITIMER	MSTD	{ int getitimer(u_int which, \
 				    struct itimerval *itv); }
-87	AUE_NULL	MCOMPAT	{ int gethostname(char *hostname, \
+87	AUE_O_GETHOSTNAME	MCOMPAT	{ int gethostname(char *hostname, \
 				    u_int len); } gethostname \
 				    gethostname_args int
-88	AUE_NULL	MCOMPAT	{ int sethostname(char *hostname, \
+88	AUE_O_SETHOSTNAME	MCOMPAT	{ int sethostname(char *hostname, \
 				    u_int len); } sethostname \
 				    sethostname_args int
-89	AUE_NULL	MSTD	{ int getdtablesize(void); }
-90	AUE_NULL	MSTD	{ int dup2(u_int from, u_int to); }
+89	AUE_GETDTABLESIZE	MSTD	{ int getdtablesize(void); }
+90	AUE_DUP2	MSTD	{ int dup2(u_int from, u_int to); }
 91	AUE_NULL	UNIMPL	getdopt
-92	AUE_NULL	MSTD	{ int fcntl(int fd, int cmd, long arg); }
+92	AUE_FCNTL	MSTD	{ 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_NULL	MSTD	{ int select(int nd, fd_set *in, fd_set *ou, \
+93	AUE_SELECT	MSTD	{ int select(int nd, fd_set *in, fd_set *ou, \
 				    fd_set *ex, struct timeval *tv); }
 94	AUE_NULL	UNIMPL	setdopt
-95	AUE_NULL	MSTD	{ int fsync(int fd); }
-96	AUE_NULL	MSTD	{ int setpriority(int which, int who, \
+95	AUE_FSYNC	MSTD	{ int fsync(int fd); }
+96	AUE_SETPRIORITY	MSTD	{ int setpriority(int which, int who, \
 				    int prio); }
-97	AUE_NULL	MSTD	{ int socket(int domain, int type, \
+97	AUE_SOCKET	MSTD	{ int socket(int domain, int type, \
 				    int protocol); }
-98	AUE_NULL	MSTD	{ int connect(int s, caddr_t name, \
+98	AUE_CONNECT	MSTD	{ int connect(int s, caddr_t name, \
 				    int namelen); }
-99	AUE_NULL	MCPT_NOA { int accept(int s, caddr_t name, \
+99	AUE_ACCEPT	MCPT_NOA { int accept(int s, caddr_t name, \
 				    int *anamelen); } accept accept_args int
-100	AUE_NULL	MSTD	{ int getpriority(int which, int who); }
-101	AUE_NULL	MCOMPAT	{ int send(int s, caddr_t buf, int len, \
+100	AUE_GETPRIORITY	MSTD	{ int getpriority(int which, int who); }
+101	AUE_O_SEND	MCOMPAT	{ int send(int s, caddr_t buf, int len, \
 				    int flags); }
-102	AUE_NULL	MCOMPAT	{ int recv(int s, caddr_t buf, int len, \
+102	AUE_O_RECV	MCOMPAT	{ int recv(int s, caddr_t buf, int len, \
 				    int flags); }
-103	AUE_NULL	MCOMPAT	{ int sigreturn( \
+103	AUE_SIGRETURN	MCOMPAT	{ int sigreturn( \
 				    struct osigcontext *sigcntxp); }
-104	AUE_NULL	MSTD	{ int bind(int s, caddr_t name, \
+104	AUE_BIND	MSTD	{ int bind(int s, caddr_t name, \
 				    int namelen); }
-105	AUE_NULL	MSTD	{ int setsockopt(int s, int level, int name, \
+105	AUE_SETSOCKOPT	MSTD	{ int setsockopt(int s, int level, int name, \
 				    caddr_t val, int valsize); }
-106	AUE_NULL	MSTD	{ int listen(int s, int backlog); }
+106	AUE_LISTEN	MSTD	{ int listen(int s, int backlog); }
 107	AUE_NULL	OBSOL	vtimes
-108	AUE_NULL	MCOMPAT	{ int sigvec(int signum, struct sigvec *nsv, \
+108	AUE_O_SIGVEC	MCOMPAT	{ int sigvec(int signum, struct sigvec *nsv, \
 				    struct sigvec *osv); }
-109	AUE_NULL	MCOMPAT	{ int sigblock(int mask); }
-110	AUE_NULL	MCOMPAT	{ int sigsetmask(int mask); }
-111	AUE_NULL	MCOMPAT	{ int sigsuspend(osigset_t mask); }
+109	AUE_O_SIGBLOCK	MCOMPAT	{ int sigblock(int mask); }
+110	AUE_O_SIGSETMASK	MCOMPAT	{ int sigsetmask(int mask); }
+111	AUE_SIGSUSPEND	MCOMPAT	{ 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	MCOMPAT	{ int sigstack(struct sigstack *nss, \
+112	AUE_O_SIGSTACK	MCOMPAT	{ int sigstack(struct sigstack *nss, \
 				    struct sigstack *oss); }
-113	AUE_NULL	MCOMPAT	{ int recvmsg(int s, struct omsghdr *msg, \
+113	AUE_O_RECVMSG	MCOMPAT	{ int recvmsg(int s, struct omsghdr *msg, \
 				    int flags); }
-114	AUE_NULL	MCOMPAT	{ int sendmsg(int s, caddr_t msg, \
+114	AUE_O_SENDMSG	MCOMPAT	{ int sendmsg(int s, caddr_t msg, \
 				    int flags); }
 115	AUE_NULL	OBSOL	vtrace
-116	AUE_NULL	MSTD	{ int gettimeofday(struct timeval *tp, \
+116	AUE_GETTIMEOFDAY	MSTD	{ int gettimeofday(struct timeval *tp, \
 				    struct timezone *tzp); }
-117	AUE_NULL	MSTD	{ int getrusage(int who, \
+117	AUE_GETRUSAGE	MSTD	{ int getrusage(int who, \
 				    struct rusage *rusage); }
-118	AUE_NULL	MSTD	{ int getsockopt(int s, int level, int name, \
+118	AUE_GTSOCKOPT	MSTD	{ int getsockopt(int s, int level, int name, \
 				    caddr_t val, int *avalsize); }
 119	AUE_NULL	UNIMPL	resuba (BSD/OS 2.x)
-120	AUE_NULL	MSTD	{ int readv(int fd, struct iovec *iovp, \
+120	AUE_READV	MSTD	{ int readv(int fd, struct iovec *iovp, \
 				    u_int iovcnt); }
-121	AUE_NULL	MSTD	{ int writev(int fd, struct iovec *iovp, \
+121	AUE_WRITEV	MSTD	{ int writev(int fd, struct iovec *iovp, \
 				    u_int iovcnt); }
-122	AUE_NULL	MSTD	{ int settimeofday(struct timeval *tv, \
+122	AUE_SETTIMEOFDAY	MSTD	{ int settimeofday(struct timeval *tv, \
 				    struct timezone *tzp); }
-123	AUE_NULL	MSTD	{ int fchown(int fd, int uid, int gid); }
-124	AUE_NULL	MSTD	{ int fchmod(int fd, int mode); }
-125	AUE_NULL	MCPT_NOA { int recvfrom(int s, caddr_t buf, \
+123	AUE_FCHOWN	MSTD	{ int fchown(int fd, int uid, int gid); }
+124	AUE_FCHMOD	MSTD	{ int fchmod(int fd, int mode); }
+125	AUE_RECVFROM	MCPT_NOA { int recvfrom(int s, caddr_t buf, \
 				    size_t len, int flags, caddr_t from, int \
 				    *fromlenaddr); } recvfrom recvfrom_args \
 				    int
-126	AUE_NULL	MSTD	{ int setreuid(int ruid, int euid); }
-127	AUE_NULL	MSTD	{ int setregid(int rgid, int egid); }
-128	AUE_NULL	MSTD	{ int rename(char *from, char *to); }
-129	AUE_NULL	MCOMPAT	{ int truncate(char *path, long length); }
-130	AUE_NULL	MCOMPAT	{ int ftruncate(int fd, long length); }
-131	AUE_NULL	MSTD	{ int flock(int fd, int how); }
-132	AUE_NULL	MSTD	{ int mkfifo(char *path, int mode); }
-133	AUE_NULL	MSTD	{ int sendto(int s, caddr_t buf, size_t len, \
+126	AUE_SETREUID	MSTD	{ int setreuid(int ruid, int euid); }
+127	AUE_SETREGID	MSTD	{ int setregid(int rgid, int egid); }
+128	AUE_RENAME	MSTD	{ int rename(char *from, char *to); }
+129	AUE_O_TRUNCATE	MCOMPAT	{ int truncate(char *path, long length); }
+130	AUE_O_FTRUNCATE	MCOMPAT	{ int ftruncate(int fd, long length); }
+131	AUE_FLOCK	MSTD	{ int flock(int fd, int how); }
+132	AUE_MKFIFO	MSTD	{ int mkfifo(char *path, int mode); }
+133	AUE_SENDTO	MSTD	{ int sendto(int s, caddr_t buf, size_t len, \
 				    int flags, caddr_t to, int tolen); }
-134	AUE_NULL	MSTD	{ int shutdown(int s, int how); }
-135	AUE_NULL	MSTD	{ int socketpair(int domain, int type, \
+134	AUE_SHUTDOWN	MSTD	{ int shutdown(int s, int how); }
+135	AUE_SOCKETPAIR	MSTD	{ int socketpair(int domain, int type, \
 				    int protocol, int *rsv); }
-136	AUE_NULL	MSTD	{ int mkdir(char *path, int mode); }
-137	AUE_NULL	MSTD	{ int rmdir(char *path); }
-138	AUE_NULL	MSTD	{ int utimes(char *path, \
+136	AUE_MKDIR	MSTD	{ int mkdir(char *path, int mode); }
+137	AUE_RMDIR	MSTD	{ int rmdir(char *path); }
+138	AUE_UTIMES	MSTD	{ int utimes(char *path, \
 				    struct timeval *tptr); }
 139	AUE_NULL	OBSOL	4.2 sigreturn
-140	AUE_NULL	MSTD	{ int adjtime(struct timeval *delta, \
+140	AUE_ADJTIME	MSTD	{ int adjtime(struct timeval *delta, \
 				    struct timeval *olddelta); }
-141	AUE_NULL	MCOMPAT	{ int getpeername(int fdes, caddr_t asa, \
+141	AUE_O_GETPEERNAME	MCOMPAT	{ int getpeername(int fdes, caddr_t asa, \
 				    int *alen); }
-142	AUE_NULL	MCOMPAT	{ long gethostid(void); }
-143	AUE_NULL	MCOMPAT	{ int sethostid(long hostid); }
-144	AUE_NULL	MCOMPAT	{ int getrlimit(u_int which, struct \
+142	AUE_O_GETHOSTID	MCOMPAT	{ long gethostid(void); }
+143	AUE_O_SETHOSTID	MCOMPAT	{ int sethostid(long hostid); }
+144	AUE_O_GETRLIMIT	MCOMPAT	{ int getrlimit(u_int which, struct \
 				    orlimit *rlp); }
-145	AUE_NULL	MCOMPAT	{ int setrlimit(u_int which, \
+145	AUE_O_SETRLIMIT	MCOMPAT	{ int setrlimit(u_int which, \
 				    struct orlimit *rlp); }
-146	AUE_NULL	MCOMPAT	{ int killpg(int pgid, int signum); }
-147	AUE_NULL	MSTD	{ int setsid(void); }
-148	AUE_NULL	MSTD	{ int quotactl(char *path, int cmd, int uid, \
+146	AUE_O_KILLPG	MCOMPAT	{ int killpg(int pgid, int signum); }
+147	AUE_SETSID	MSTD	{ int setsid(void); }
+148	AUE_QUOTACTL	MSTD	{ int quotactl(char *path, int cmd, int uid, \
 				    caddr_t arg); }
-149	AUE_NULL	MCOMPAT	{ int quota(void); }
-150	AUE_NULL	MCPT_NOA	{ int getsockname(int fdec, \
+149	AUE_O_QUOTA	MCOMPAT	{ int quota(void); }
+150	AUE_GETSOCKNAME	MCPT_NOA	{ int getsockname(int fdec, \
 				    caddr_t asa, int *alen); } getsockname \
 				    getsockname_args int
 
@@ -303,21 +303,21 @@
 153	AUE_NULL	UNIMPL	asyncdaemon (BSD/OS 2.x)
 154	AUE_NULL	UNIMPL	nosys
 ; 155 is initialized by the NFS code, if present.
-155	AUE_NULL	MNOIMPL	{ int nfssvc(int flag, caddr_t argp); }
-156	AUE_NULL	COMPAT	{ int getdirentries(int fd, char *buf, \
+155	AUE_NFSSVC	MNOIMPL	{ int nfssvc(int flag, caddr_t argp); }
+156	AUE_GETDIRENTRIES	COMPAT	{ int getdirentries(int fd, char *buf, \
 				    u_int count, long *basep); }
-157	AUE_NULL	MCOMPAT4	{ int statfs(char *path, \
+157	AUE_STATFS	MCOMPAT4	{ int statfs(char *path, \
 				    struct ostatfs *buf); }
-158	AUE_NULL	MCOMPAT4	{ int fstatfs(int fd, \
+158	AUE_FSTATFS	MCOMPAT4	{ int fstatfs(int fd, \
 				    struct ostatfs *buf); }
 159	AUE_NULL	UNIMPL	nosys
-160	AUE_NULL	MSTD	{ int lgetfh(char *fname, \
+160	AUE_LGETFH	MSTD	{ int lgetfh(char *fname, \
 				    struct fhandle *fhp); }
-161	AUE_NULL	MSTD	{ int getfh(char *fname, \
+161	AUE_NFS_GETFH	MSTD	{ int getfh(char *fname, \
 				    struct fhandle *fhp); }
-162	AUE_NULL	MSTD	{ int getdomainname(char *domainname, \
+162	AUE_SYSCTL	MSTD	{ int getdomainname(char *domainname, \
 				    int len); }
-163	AUE_NULL	MSTD	{ int setdomainname(char *domainname, \
+163	AUE_SYSCTL	MSTD	{ int setdomainname(char *domainname, \
 				    int len); }
 164	AUE_NULL	MSTD	{ int uname(struct utsname *name); }
 165	AUE_NULL	MSTD	{ int sysarch(int op, char *parms); }
@@ -326,72 +326,72 @@
 167	AUE_NULL	UNIMPL	nosys
 168	AUE_NULL	UNIMPL	nosys
 ; 169 is initialized by the SYSVSEM code if present or loaded
-169	AUE_NULL	MNOSTD	{ int semsys(int which, int a2, int a3, \
+169	AUE_SEMSYS	MNOSTD	{ int semsys(int which, int a2, int a3, \
 				    int a4, int a5); }
 ; 169 is initialized by the SYSVMSG code if present or loaded
 ; XXX should be	{ int semsys(int which, ...); }
-170	AUE_NULL	MNOSTD	{ int msgsys(int which, int a2, int a3, \
+170	AUE_MSGSYS	MNOSTD	{ int msgsys(int which, int a2, int a3, \
 				    int a4, int a5, int a6); }
 ; 169 is initialized by the SYSVSHM code if present or loaded
 ; XXX should be	{ int msgsys(int which, ...); }
-171	AUE_NULL	MNOSTD	{ int shmsys(int which, int a2, int a3, \
+171	AUE_SHMSYS	MNOSTD	{ int shmsys(int which, int a2, int a3, \
 				    int a4); }
 ; XXX should be	{ int shmsys(int which, ...); }
 172	AUE_NULL	UNIMPL	nosys
-173	AUE_NULL	MSTD	{ ssize_t pread(int fd, void *buf, \
+173	AUE_PREAD	MSTD	{ ssize_t pread(int fd, void *buf, \
 				    size_t nbyte, int pad, off_t offset); }
-174	AUE_NULL	MSTD	{ ssize_t pwrite(int fd, const void *buf, \
+174	AUE_PWRITE	MSTD	{ ssize_t pwrite(int fd, const void *buf, \
 				    size_t nbyte, int pad, off_t offset); }
 175	AUE_NULL	UNIMPL	nosys
-176	AUE_NULL	MSTD	{ int ntp_adjtime(struct timex *tp); }
+176	AUE_ADJTIME	MSTD	{ int ntp_adjtime(struct timex *tp); }
 177	AUE_NULL	UNIMPL	sfork (BSD/OS 2.x)
 178	AUE_NULL	UNIMPL	getdescriptor (BSD/OS 2.x)
 179	AUE_NULL	UNIMPL	setdescriptor (BSD/OS 2.x)
 180	AUE_NULL	UNIMPL	nosys
 
 ; Syscalls 181-199 are used by/reserved for BSD
-181	AUE_NULL	MSTD	{ int setgid(gid_t gid); }
-182	AUE_NULL	MSTD	{ int setegid(gid_t egid); }
-183	AUE_NULL	MSTD	{ int seteuid(uid_t euid); }
+181	AUE_SETGID	MSTD	{ int setgid(gid_t gid); }
+182	AUE_SETEGID	MSTD	{ int setegid(gid_t egid); }
+183	AUE_SETEUID	MSTD	{ int seteuid(uid_t euid); }
 184	AUE_NULL	UNIMPL	lfs_bmapv
 185	AUE_NULL	UNIMPL	lfs_markv
 186	AUE_NULL	UNIMPL	lfs_segclean
 187	AUE_NULL	UNIMPL	lfs_segwait
-188	AUE_NULL	MSTD	{ int stat(char *path, struct stat *ub); }
-189	AUE_NULL	MSTD	{ int fstat(int fd, struct stat *sb); }
-190	AUE_NULL	MSTD	{ int lstat(char *path, struct stat *ub); }
-191	AUE_NULL	MSTD	{ int pathconf(char *path, int name); }
-192	AUE_NULL	MSTD	{ int fpathconf(int fd, int name); }
+188	AUE_STAT	MSTD	{ int stat(char *path, struct stat *ub); }
+189	AUE_FSTAT	MSTD	{ int fstat(int fd, struct stat *sb); }
+190	AUE_LSTAT	MSTD	{ int lstat(char *path, struct stat *ub); }
+191	AUE_PATHCONF	MSTD	{ int pathconf(char *path, int name); }
+192	AUE_FPATHCONF	MSTD	{ int fpathconf(int fd, int name); }
 193	AUE_NULL	UNIMPL	nosys
-194	AUE_NULL	MSTD	{ int getrlimit(u_int which, \
+194	AUE_GETRLIMIT	MSTD	{ int getrlimit(u_int which, \
 				    struct rlimit *rlp); } getrlimit \
 				    __getrlimit_args int
-195	AUE_NULL	MSTD	{ int setrlimit(u_int which, \
+195	AUE_SETRLIMIT	MSTD	{ int setrlimit(u_int which, \
 				    struct rlimit *rlp); } setrlimit \
 				    __setrlimit_args int
-196	AUE_NULL	MSTD	{ int getdirentries(int fd, char *buf, \
+196	AUE_GETDIRENTRIES	MSTD	{ int getdirentries(int fd, char *buf, \
 				    u_int count, long *basep); }
-197	AUE_NULL	MSTD	{ caddr_t mmap(caddr_t addr, size_t len, \
+197	AUE_MMAP	MSTD	{ caddr_t mmap(caddr_t addr, size_t len, \
 				    int prot, int flags, int fd, int pad, \
 				    off_t pos); }
 198	AUE_NULL	MSTD	{ int nosys(void); } __syscall \
 				    __syscall_args int
-199	AUE_NULL	MSTD	{ off_t lseek(int fd, int pad, off_t offset, \
+199	AUE_LSEEK	MSTD	{ off_t lseek(int fd, int pad, off_t offset, \
 				    int whence); }
-200	AUE_NULL	MSTD	{ int truncate(char *path, int pad, \
+200	AUE_TRUNCATE	MSTD	{ int truncate(char *path, int pad, \
 				    off_t length); }
-201	AUE_NULL	MSTD	{ int ftruncate(int fd, int pad, \
+201	AUE_FTRUNCATE	MSTD	{ int ftruncate(int fd, int pad, \
 				    off_t length); }
-202	AUE_NULL	MSTD	{ int __sysctl(int *name, u_int namelen, \
+202	AUE_SYSCTL	MSTD	{ int __sysctl(int *name, u_int namelen, \
 				    void *old, size_t *oldlenp, void *new, \
 				    size_t newlen); } __sysctl sysctl_args int
-203	AUE_NULL	MSTD	{ int mlock(const void *addr, size_t len); }
-204	AUE_NULL	MSTD	{ int munlock(const void *addr, size_t len); }
-205	AUE_NULL	MSTD	{ int undelete(char *path); }
-206	AUE_NULL	MSTD	{ int futimes(int fd, struct timeval *tptr); }
-207	AUE_NULL	MSTD	{ int getpgid(pid_t pid); }
+203	AUE_MLOCK	MSTD	{ int mlock(const void *addr, size_t len); }
+204	AUE_MUNLOCK	MSTD	{ int munlock(const void *addr, size_t len); }
+205	AUE_UNDELETE	MSTD	{ int undelete(char *path); }
+206	AUE_FUTIMES	MSTD	{ int futimes(int fd, struct timeval *tptr); }
+207	AUE_GETPGID	MSTD	{ int getpgid(pid_t pid); }
 208	AUE_NULL	UNIMPL	newreboot (NetBSD)
-209	AUE_NULL	MSTD	{ int poll(struct pollfd *fds, u_int nfds, \
+209	AUE_POLL	MSTD	{ int poll(struct pollfd *fds, u_int nfds, \
 				    int timeout); }
 
 ;
@@ -410,27 +410,26 @@
 
 ;
 ; The following were introduced with NetBSD/4.4Lite-2
-; They are initialized by their respective modules/sysinits
-220	AUE_NULL	MNOSTD	{ int __semctl(int semid, int semnum, \
+220	AUE_SEMCTL	MNOSTD	{ int __semctl(int semid, int semnum, \
 				    int cmd, union semun *arg); }
-221	AUE_NULL	MNOSTD	{ int semget(key_t key, int nsems, \
+221	AUE_SEMGET	MNOSTD	{ int semget(key_t key, int nsems, \
 				    int semflg); }
-222	AUE_NULL	MNOSTD	{ int semop(int semid, struct sembuf *sops, \
+222	AUE_SEMOP	MNOSTD	{ int semop(int semid, struct sembuf *sops, \
 				    size_t nsops); }
 223	AUE_NULL	UNIMPL	semconfig
-224	AUE_NULL	MNOSTD	{ int msgctl(int msqid, int cmd, \
+224	AUE_MSGCTL	MNOSTD	{ int msgctl(int msqid, int cmd, \
 				    struct msqid_ds *buf); }
-225	AUE_NULL	MNOSTD	{ int msgget(key_t key, int msgflg); }
-226	AUE_NULL	MNOSTD	{ int msgsnd(int msqid, const void *msgp, \
+225	AUE_MSGGET	MNOSTD	{ int msgget(key_t key, int msgflg); }
+226	AUE_MSGSND	MNOSTD	{ int msgsnd(int msqid, const void *msgp, \
 				    size_t msgsz, int msgflg); }
-227	AUE_NULL	MNOSTD	{ int msgrcv(int msqid, void *msgp, \
+227	AUE_MSGRCV	MNOSTD	{ int msgrcv(int msqid, void *msgp, \
 				    size_t msgsz, long msgtyp, int msgflg); }
-228	AUE_NULL	MNOSTD	{ int shmat(int shmid, const void *shmaddr, \
+228	AUE_SHMAT	MNOSTD	{ int shmat(int shmid, const void *shmaddr, \
 				    int shmflg); }
-229	AUE_NULL	MNOSTD	{ int shmctl(int shmid, int cmd, \
+229	AUE_SHMCTL	MNOSTD	{ int shmctl(int shmid, int cmd, \
 				    struct shmid_ds *buf); }
-230	AUE_NULL	MNOSTD	{ int shmdt(const void *shmaddr); }
-231	AUE_NULL	MNOSTD	{ int shmget(key_t key, size_t size, \
+230	AUE_SHMDT	MNOSTD	{ int shmdt(const void *shmaddr); }
+231	AUE_SHMGET	MNOSTD	{ int shmget(key_t key, size_t size, \
 				    int shmflg); }
 ;
 232	AUE_NULL	MSTD	{ int clock_gettime(clockid_t clock_id, \
@@ -460,13 +459,13 @@
 248	AUE_NULL	MSTD	{ int ntp_gettime(struct ntptimeval *ntvp); }
 249	AUE_NULL	UNIMPL	nosys
 ; syscall numbers initially used in OpenBSD
-250	AUE_NULL	MSTD	{ int minherit(void *addr, size_t len, \
+250	AUE_MINHERIT	MSTD	{ int minherit(void *addr, size_t len, \
 				    int inherit); }
-251	AUE_NULL	MSTD	{ int rfork(int flags); }
-252	AUE_NULL	MSTD	{ int openbsd_poll(struct pollfd *fds, \
+251	AUE_RFORK	MSTD	{ int rfork(int flags); }
+252	AUE_POLL	MSTD	{ int openbsd_poll(struct pollfd *fds, \
 				    u_int nfds, int timeout); }
-253	AUE_NULL	MSTD	{ int issetugid(void); }
-254	AUE_NULL	MSTD	{ int lchown(char *path, int uid, int gid); }
+253	AUE_ISSETUGID	MSTD	{ int issetugid(void); }
+254	AUE_LCHOWN	MSTD	{ int lchown(char *path, int uid, int gid); }
 255	AUE_NULL	MNOSTD	{ int aio_read(struct aiocb *aiocbp); }
 256	AUE_NULL	MNOSTD	{ int aio_write(struct aiocb *aiocbp); }
 257	AUE_NULL	MNOSTD	{ int lio_listio(int mode, \
@@ -486,20 +485,20 @@
 269	AUE_NULL	UNIMPL	nosys
 270	AUE_NULL	UNIMPL	nosys
 271	AUE_NULL	UNIMPL	nosys
-272	AUE_NULL	MSTD	{ int getdents(int fd, char *buf, \
+272	AUE_O_GETDENTS	MSTD	{ int getdents(int fd, char *buf, \
 				    size_t count); }
 273	AUE_NULL	UNIMPL	nosys
-274	AUE_NULL	MSTD	{ int lchmod(char *path, mode_t mode); }
-275	AUE_NULL	MNOPROTO { int lchown(char *path, uid_t uid, \
+274	AUE_LCHMOD	MSTD	{ int lchmod(char *path, mode_t mode); }
+275	AUE_LCHOWN	MNOPROTO { int lchown(char *path, uid_t uid, \
 				    gid_t gid); } netbsd_lchown lchown_args \
 				    int
-276	AUE_NULL	MSTD	{ int lutimes(char *path, \
+276	AUE_LUTIMES	MSTD	{ int lutimes(char *path, \
 				    struct timeval *tptr); }
-277	AUE_NULL	MNOPROTO	{ int msync(void *addr, size_t len, \
+277	AUE_MSYNC	MNOPROTO	{ int msync(void *addr, size_t len, \
 				    int flags); } netbsd_msync msync_args int
-278	AUE_NULL	MSTD	{ int nstat(char *path, struct nstat *ub); }
-279	AUE_NULL	MSTD	{ int nfstat(int fd, struct nstat *sb); }
-280	AUE_NULL	MSTD	{ int nlstat(char *path, struct nstat *ub); }
+278	AUE_STAT	MSTD	{ int nstat(char *path, struct nstat *ub); }
+279	AUE_FSTAT	MSTD	{ int nfstat(int fd, struct nstat *sb); }
+280	AUE_LSTAT	MSTD	{ int nlstat(char *path, struct nstat *ub); }
 281	AUE_NULL	UNIMPL	nosys
 282	AUE_NULL	UNIMPL	nosys
 283	AUE_NULL	UNIMPL	nosys
@@ -520,12 +519,12 @@
 295	AUE_NULL	UNIMPL	nosys
 296	AUE_NULL	UNIMPL	nosys
 ; XXX 297 is 300 in NetBSD 
-297	AUE_NULL	MCOMPAT4	{ int fhstatfs( \
+297	AUE_FHSTATFS	MCOMPAT4	{ int fhstatfs( \
 				    const struct fhandle *u_fhp, \
 				    struct ostatfs *buf); }
-298	AUE_NULL	MSTD	{ int fhopen(const struct fhandle *u_fhp, \
+298	AUE_FHOPEN	MSTD	{ int fhopen(const struct fhandle *u_fhp, \
 				    int flags); }
-299	AUE_NULL	MSTD	{ int fhstat(const struct fhandle *u_fhp, \
+299	AUE_FHSTAT	MSTD	{ int fhstat(const struct fhandle *u_fhp, \
 				    struct stat *sb); }
 ; syscall numbers for FreeBSD
 300	AUE_NULL	MSTD	{ int modnext(int modid); }
@@ -533,17 +532,17 @@
 				    struct module_stat *stat); }
 302	AUE_NULL	MSTD	{ int modfnext(int modid); }
 303	AUE_NULL	MSTD	{ int modfind(const char *name); }
-304	AUE_NULL	MSTD	{ int kldload(const char *file); }
-305	AUE_NULL	MSTD	{ int kldunload(int fileid); }
+304	AUE_MODLOAD	MSTD	{ int kldload(const char *file); }
+305	AUE_MODUNLOAD	MSTD	{ int kldunload(int fileid); }
 306	AUE_NULL	MSTD	{ int kldfind(const char *file); }
 307	AUE_NULL	MSTD	{ int kldnext(int fileid); }
 308	AUE_NULL	MSTD	{ int kldstat(int fileid, struct \
 				    kld_file_stat* stat); }
 309	AUE_NULL	MSTD	{ int kldfirstmod(int fileid); }
-310	AUE_NULL	MSTD	{ int getsid(pid_t pid); }
-311	AUE_NULL	MSTD	{ int setresuid(uid_t ruid, uid_t euid, \
+310	AUE_GETSID	MSTD	{ int getsid(pid_t pid); }
+311	AUE_SETRESUID	MSTD	{ int setresuid(uid_t ruid, uid_t euid, \
 				    uid_t suid); }
-312	AUE_NULL	MSTD	{ int setresgid(gid_t rgid, gid_t egid, \
+312	AUE_SETRESGID	MSTD	{ int setresgid(gid_t rgid, gid_t egid, \
 				    gid_t sgid); }
 313	AUE_NULL	OBSOL	signanosleep
 314	AUE_NULL	MNOSTD	{ int aio_return(struct aiocb *aiocbp); }
@@ -561,8 +560,8 @@
 321	AUE_NULL	MSTD	{ int yield(void); }
 322	AUE_NULL	OBSOL	thr_sleep
 323	AUE_NULL	OBSOL	thr_wakeup
-324	AUE_NULL	MSTD	{ int mlockall(int how); }
-325	AUE_NULL	MSTD	{ int munlockall(void); }
+324	AUE_MLOCKALL	MSTD	{ int mlockall(int how); }
+325	AUE_MUNLOCKALL	MSTD	{ int munlockall(void); }
 326	AUE_NULL	MSTD	{ int __getcwd(u_char *buf, u_int buflen); }
 
 327	AUE_NULL	MSTD	{ int sched_setparam (pid_t pid, \
@@ -581,24 +580,24 @@
 334	AUE_NULL	MSTD	{ int sched_rr_get_interval (pid_t pid, \
 				    struct timespec *interval); }
 335	AUE_NULL	MSTD	{ int utrace(const void *addr, size_t len); }
-336	AUE_NULL	MCOMPAT4	{ int sendfile(int fd, int s, \
+336	AUE_SENDFILE	MCOMPAT4	{ int sendfile(int fd, int s, \
 				    off_t offset, size_t nbytes, \
 				    struct sf_hdtr *hdtr, off_t *sbytes, \
 				    int flags); }
 337	AUE_NULL	MSTD	{ int kldsym(int fileid, int cmd, \
 				    void *data); }
-338	AUE_NULL	MSTD	{ int jail(struct jail *jail); }
+338	AUE_JAIL	MSTD	{ int jail(struct jail *jail); }
 339	AUE_NULL	UNIMPL	pioctl
-340	AUE_NULL	MSTD	{ int sigprocmask(int how, \
+340	AUE_SIGPROCMASK	MSTD	{ int sigprocmask(int how, \
 				    const sigset_t *set, sigset_t *oset); }
-341	AUE_NULL	MSTD	{ int sigsuspend(const sigset_t *sigmask); }
-342	AUE_NULL	MCOMPAT4	{ int sigaction(int sig, const \
+341	AUE_SIGSUSPEND	MSTD	{ int sigsuspend(const sigset_t *sigmask); }
+342	AUE_SIGACTION	MCOMPAT4	{ int sigaction(int sig, const \
 				    struct sigaction *act, \
 				    struct sigaction *oact); }
-343	AUE_NULL	MSTD	{ int sigpending(sigset_t *set); }
-344	AUE_NULL	MCOMPAT4	{ int sigreturn( \
+343	AUE_SIGPENDING	MSTD	{ int sigpending(sigset_t *set); }
+344	AUE_SIGRETURN	MCOMPAT4	{ int sigreturn( \
 				    const struct ucontext4 *sigcntxp); }
-345	AUE_NULL	MSTD	{ int sigtimedwait(const sigset_t *set, \
+345	AUE_SIGWAIT	MSTD	{ int sigtimedwait(const sigset_t *set, \
 				    siginfo_t *info, \
 				    const struct timespec *timeout); }
 346	AUE_NULL	MSTD	{ int sigwaitinfo(const sigset_t *set, \
@@ -634,9 +633,9 @@
 359	AUE_NULL	MNOSTD	{ int aio_waitcomplete( \
 				    struct aiocb **aiocbp, \
 				    struct timespec *timeout); }
-360	AUE_NULL	MSTD	{ int getresuid(uid_t *ruid, uid_t *euid, \
+360	AUE_GETRESUID	MSTD	{ int getresuid(uid_t *ruid, uid_t *euid, \
 				    uid_t *suid); }
-361	AUE_NULL	MSTD	{ int getresgid(gid_t *rgid, gid_t *egid, \
+361	AUE_GETRESGID	MSTD	{ int getresgid(gid_t *rgid, gid_t *egid, \
 				    gid_t *sgid); }
 362	AUE_NULL	MSTD	{ int kqueue(void); }
 363	AUE_NULL	MSTD	{ int kevent(int fd, \
@@ -661,7 +660,7 @@
 				    const char *attrname); }
 374	AUE_NULL	MSTD	{ int __setugid(int flag); }
 375	AUE_NULL	NOIMPL	{ int nfsclnt(int flag, caddr_t argp); }
-376	AUE_NULL	MSTD	{ int eaccess(char *path, int flags); }
+376	AUE_EACCESS	MSTD	{ int eaccess(char *path, int flags); }
 377	AUE_NULL	UNIMPL	afs_syscall
 378	AUE_NULL	STD	{ int nmount(struct iovec *iovp, \
 				    unsigned int iovcnt, int flags); }
@@ -685,19 +684,19 @@
 				    struct mac *mac_p); }
 390	AUE_NULL	MSTD	{ int kenv(int what, const char *name, \
 				    char *value, int len); }
-391	AUE_NULL	MSTD	{ int lchflags(const char *path, int flags); }
+391	AUE_LCHFLAGS	MSTD	{ int lchflags(const char *path, int flags); }
 392	AUE_NULL	MSTD	{ int uuidgen(struct uuid *store, \
 				    int count); }
-393	AUE_NULL	MSTD	{ int sendfile(int fd, int s, off_t offset, \
+393	AUE_SENDFILE	MSTD	{ int sendfile(int fd, int s, off_t offset, \
 				    size_t nbytes, struct sf_hdtr *hdtr, \
 				    off_t *sbytes, int flags); }
 394	AUE_NULL	MSTD	{ int mac_syscall(const char *policy, \
 				    int call, void *arg); }
-395	AUE_NULL	MSTD	{ int getfsstat(struct statfs *buf, \
+395	AUE_GETFSSTAT	MSTD	{ int getfsstat(struct statfs *buf, \
 				    long bufsize, int flags); }
-396	AUE_NULL	MSTD	{ int statfs(char *path, \
+396	AUE_STATFS	MSTD	{ int statfs(char *path, \
 				    struct statfs *buf); }
-397	AUE_NULL	MSTD	{ int fstatfs(int fd, struct statfs *buf); }
+397	AUE_FSTATFS	MSTD	{ int fstatfs(int fd, struct statfs *buf); }
 398	AUE_NULL	MSTD	{ int fhstatfs(const struct fhandle *u_fhp, \
 				    struct statfs *buf); }
 399	AUE_NULL	UNIMPL	nosys
@@ -730,10 +729,10 @@
 				    const char *attrname); }
 415	AUE_NULL	MSTD	{ int __mac_execve(char *fname, char **argv, \
 				    char **envv, struct mac *mac_p); }
-416	AUE_NULL	MSTD	{ int sigaction(int sig, \
+416	AUE_SIGACTION	MSTD	{ int sigaction(int sig, \
 				    const struct sigaction *act, \
 				    struct sigaction *oact); }
-417	AUE_NULL	MSTD	{ int sigreturn( \
+417	AUE_SIGRETURN	MSTD	{ int sigreturn( \
 				    const struct __ucontext *sigcntxp); }
 418	AUE_NULL	UNIMPL	__xstat
 419	AUE_NULL	UNIMPL	__xfstat
@@ -743,7 +742,7 @@
 				    const struct __ucontext *ucp); }
 423	AUE_NULL	MSTD	{ int swapcontext(struct __ucontext *oucp, \
 				    const struct __ucontext *ucp); }
-424	AUE_NULL	MSTD	{ int swapoff(const char *name); }
+424	AUE_SWAPOFF	MSTD	{ int swapoff(const char *name); }
 425	AUE_NULL	MSTD	{ int __acl_get_link(const char *path, \
 				    acl_type_t type, struct acl *aclp); }
 426	AUE_NULL	MSTD	{ int __acl_set_link(const char *path, \
@@ -752,7 +751,7 @@
 				    acl_type_t type); }
 428	AUE_NULL	MSTD	{ int __acl_aclcheck_link(const char *path, \
 				    acl_type_t type, struct acl *aclp); }
-429	AUE_NULL	MSTD	{ int sigwait(const sigset_t *set, \
+429	AUE_SIGWAIT	MSTD	{ int sigwait(const sigset_t *set, \
 				    int *sig); }
 430	AUE_NULL	MSTD	{ int thr_create(ucontext_t *ctx, long *id, \
 				    int flags); }