Now that all system calls are MPSAFE, retire the SYF_MPSAFE flag used to

mark system calls as being MPSAFE:
- Stop conditionally acquiring Giant around system call invocations.
- Remove all of the 'M' prefixes from the master system call files.
- Remove support for the 'M' prefix from the script that generates the
  syscall-related files from the master system call files.
- Don't explicitly set SYF_MPSAFE when registering nfssvc.

1 files changed, 377 insertions, 381 deletions

diff --git a/sys/kern/syscalls.master b/sys/kern/syscalls.master
index da1b02b4e951..960d4e94bdf7 100644
--- a/sys/kern/syscalls.master
+++ b/sys/kern/syscalls.master
@@ -4,16 +4,15 @@
 ; System call name/number master file.
 ; Processed to created init_sysent.c, syscalls.c and syscall.h.
 
-; Columns: number audit [M]type name alt{name,tag,rtyp}/comments
+; 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 [M]STD, [M]OBSOL, [M]UNIMPL, [M]COMPAT, [M]CPT_NOA,
-;		[M]LIBCOMPAT, [M]NODEF, [M]NOARGS, [M]NOPROTO, [M]NOIMPL,
-;		[M]NOSTD, [M]COMPAT4
+;	type	one of STD, OBSOL, UNIMPL, COMPAT, CPT_NOA, LIBCOMPAT,
+;		NODEF, NOARGS, NOPROTO, NOIMPL, NOSTD, COMPAT4
 ;	name	psuedo-prototype of syscall routine
 ;		If one of the following alts is different, then all appear:
 ;	altname	name of system call if different
@@ -22,9 +21,6 @@
 ;		for UNIMPL/OBSOL, name continues with comments
 
 ; types:
-;	[M]	e.g. like MSTD -- means the system call is MP-safe.  If no
-;		M prefix is used, the syscall wrapper will obtain the Giant
-;		lock for the syscall.
 ;	STD	always included
 ;	COMPAT	included on COMPAT #ifdef
 ;	COMPAT4	included on COMPAT4 #ifdef (FreeBSD 4 compat)
@@ -50,247 +46,247 @@
 ; redistributions should be placed in the reserved range at the end
 ; of the current calls.
 
-0	AUE_NULL	MSTD	{ int nosys(void); } syscall nosys_args int
-1	AUE_EXIT	MSTD	{ void sys_exit(int rval); } exit \
+0	AUE_NULL	STD	{ int nosys(void); } syscall nosys_args int
+1	AUE_EXIT	STD	{ void sys_exit(int rval); } exit \
 				    sys_exit_args void
-2	AUE_FORK	MSTD	{ int fork(void); }
-3	AUE_NULL	MSTD	{ ssize_t read(int fd, void *buf, \
+2	AUE_FORK	STD	{ int fork(void); }
+3	AUE_NULL	STD	{ ssize_t read(int fd, void *buf, \
 				    size_t nbyte); }
-4	AUE_NULL	MSTD	{ ssize_t write(int fd, const void *buf, \
+4	AUE_NULL	STD	{ ssize_t write(int fd, const void *buf, \
 				    size_t nbyte); }
-5	AUE_OPEN_RWTC	MSTD	{ int open(char *path, int flags, int mode); }
+5	AUE_OPEN_RWTC	STD	{ 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_CLOSE	MSTD	{ int close(int fd); }
-7	AUE_WAIT4	MSTD	{ int wait4(int pid, int *status, \
+6	AUE_CLOSE	STD	{ int close(int fd); }
+7	AUE_WAIT4	STD	{ int wait4(int pid, int *status, \
 				    int options, struct rusage *rusage); } \
 				    wait4 wait_args int
-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); }
+8	AUE_O_CREAT	COMPAT	{ int creat(char *path, int mode); }
+9	AUE_LINK	STD	{ int link(char *path, char *link); }
+10	AUE_UNLINK	STD	{ int unlink(char *path); }
 11	AUE_NULL	OBSOL	execv
-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 \
+12	AUE_CHDIR	STD	{ int chdir(char *path); }
+13	AUE_FCHDIR	STD	{ int fchdir(int fd); }
+14	AUE_MKNOD	STD	{ int mknod(char *path, int mode, int dev); }
+15	AUE_CHMOD	STD	{ int chmod(char *path, int mode); }
+16	AUE_CHOWN	STD	{ int chown(char *path, int uid, int gid); }
+17	AUE_NULL	STD	{ int obreak(char *nsize); } break \
 				    obreak_args int
-18	AUE_GETFSSTAT	MCOMPAT4	{ int getfsstat(struct ostatfs *buf, \
+18	AUE_GETFSSTAT	COMPAT4	{ int getfsstat(struct ostatfs *buf, \
 				    long bufsize, int flags); }
-19	AUE_LSEEK	MCOMPAT	{ long lseek(int fd, long offset, \
+19	AUE_LSEEK	COMPAT	{ long lseek(int fd, long offset, \
 				    int whence); }
-20	AUE_GETPID	MSTD	{ pid_t getpid(void); }
-21	AUE_MOUNT	MSTD	{ int mount(char *type, char *path, \
+20	AUE_GETPID	STD	{ 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_UMOUNT	MSTD	{ 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, \
+22	AUE_UMOUNT	STD	{ int unmount(char *path, int flags); }
+23	AUE_SETUID	STD	{ int setuid(uid_t uid); }
+24	AUE_GETUID	STD	{ uid_t getuid(void); }
+25	AUE_GETEUID	STD	{ uid_t geteuid(void); }
+26	AUE_PTRACE	STD	{ int ptrace(int req, pid_t pid, \
 				    caddr_t addr, int data); }
-27	AUE_RECVMSG	MSTD	{ int recvmsg(int s, struct msghdr *msg, \
+27	AUE_RECVMSG	STD	{ int recvmsg(int s, struct msghdr *msg, \
 				    int flags); }
-28	AUE_SENDMSG	MSTD	{ int sendmsg(int s, struct msghdr *msg, \
+28	AUE_SENDMSG	STD	{ int sendmsg(int s, struct msghdr *msg, \
 				    int flags); }
-29	AUE_RECVFROM	MSTD	{ int recvfrom(int s, caddr_t buf, \
+29	AUE_RECVFROM	STD	{ int recvfrom(int s, caddr_t buf, \
 				    size_t len, int flags, \
 				    struct sockaddr * __restrict from, \
 				    __socklen_t * __restrict fromlenaddr); }
-30	AUE_ACCEPT	MSTD	{ int accept(int s, \
+30	AUE_ACCEPT	STD	{ int accept(int s, \
 				    struct sockaddr * __restrict name, \
 				    __socklen_t * __restrict anamelen); }
-31	AUE_GETPEERNAME	MSTD	{ int getpeername(int fdes, \
+31	AUE_GETPEERNAME	STD	{ int getpeername(int fdes, \
 				    struct sockaddr * __restrict asa, \
 				    __socklen_t * __restrict alen); }
-32	AUE_GETSOCKNAME	MSTD	{ int getsockname(int fdes, \
+32	AUE_GETSOCKNAME	STD	{ int getsockname(int fdes, \
 				    struct sockaddr * __restrict asa, \
 				    __socklen_t * __restrict alen); }
-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, \
+33	AUE_ACCESS	STD	{ int access(char *path, int flags); }
+34	AUE_CHFLAGS	STD	{ int chflags(char *path, int flags); }
+35	AUE_FCHFLAGS	STD	{ int fchflags(int fd, int flags); }
+36	AUE_SYNC	STD	{ int sync(void); }
+37	AUE_KILL	STD	{ int kill(int pid, int signum); }
+38	AUE_STAT	COMPAT	{ int stat(char *path, struct ostat *ub); }
+39	AUE_GETPPID	STD	{ pid_t getppid(void); }
+40	AUE_LSTAT	COMPAT	{ int lstat(char *path, struct ostat *ub); }
+41	AUE_DUP		STD	{ int dup(u_int fd); }
+42	AUE_PIPE	STD	{ int pipe(void); }
+43	AUE_GETEGID	STD	{ gid_t getegid(void); }
+44	AUE_PROFILE	STD	{ int profil(caddr_t samples, size_t size, \
 				    size_t offset, u_int scale); }
-45	AUE_KTRACE	MSTD	{ int ktrace(const char *fname, int ops, \
+45	AUE_KTRACE	STD	{ int ktrace(const char *fname, int ops, \
 				    int facs, int pid); }
-46	AUE_SIGACTION	MCOMPAT	{ int sigaction(int signum, \
+46	AUE_SIGACTION	COMPAT	{ int sigaction(int signum, \
 				    struct osigaction *nsa, \
 				    struct osigaction *osa); }
-47	AUE_GETGID	MSTD	{ gid_t getgid(void); }
-48	AUE_SIGPROCMASK	MCOMPAT	{ int sigprocmask(int how, osigset_t mask); }
+47	AUE_GETGID	STD	{ gid_t getgid(void); }
+48	AUE_SIGPROCMASK	COMPAT	{ 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	MSTD	{ int getlogin(char *namebuf, u_int \
+49	AUE_GETLOGIN	STD	{ int getlogin(char *namebuf, u_int \
 				    namelen); }
-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, \
+50	AUE_SETLOGIN	STD	{ int setlogin(char *namebuf); }
+51	AUE_ACCT	STD	{ int acct(char *path); }
+52	AUE_SIGPENDING	COMPAT	{ int sigpending(void); }
+53	AUE_SIGPENDING	STD	{ int sigaltstack(stack_t *ss, \
 				    stack_t *oss); }
-54	AUE_IOCTL	MSTD	{ int ioctl(int fd, u_long com, \
+54	AUE_IOCTL	STD	{ int ioctl(int fd, u_long com, \
 				    caddr_t data); }
-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, \
+55	AUE_REBOOT	STD	{ int reboot(int opt); }
+56	AUE_REVOKE	STD	{ int revoke(char *path); }
+57	AUE_SYMLINK	STD	{ int symlink(char *path, char *link); }
+58	AUE_READLINK	STD	{ int readlink(char *path, char *buf, \
 				    int count); }
-59	AUE_EXECVE	MSTD	{ int execve(char *fname, char **argv, \
+59	AUE_EXECVE	STD	{ int execve(char *fname, char **argv, \
 				    char **envv); }
-60	AUE_UMASK	MSTD	{ int umask(int newmask); } umask umask_args \
+60	AUE_UMASK	STD	{ int umask(int newmask); } umask umask_args \
 				    int
-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, \
+61	AUE_CHROOT	STD	{ int chroot(char *path); }
+62	AUE_FSTAT	COMPAT	{ int fstat(int fd, struct ostat *sb); }
+63	AUE_NULL	COMPAT	{ int getkerninfo(int op, char *where, \
 				    size_t *size, int arg); } getkerninfo \
 				    getkerninfo_args int
-64	AUE_O_GETPAGESIZE	MCOMPAT	{ int getpagesize(void); } getpagesize \
+64	AUE_O_GETPAGESIZE	COMPAT	{ int getpagesize(void); } getpagesize \
 				    getpagesize_args int
-65	AUE_MSYNC	MSTD	{ int msync(void *addr, size_t len, \
+65	AUE_MSYNC	STD	{ int msync(void *addr, size_t len, \
 				    int flags); }
-66	AUE_VFORK	MSTD	{ int vfork(void); }
+66	AUE_VFORK	STD	{ int vfork(void); }
 67	AUE_NULL	OBSOL	vread
 68	AUE_NULL	OBSOL	vwrite
-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, \
+69	AUE_SBRK	STD	{ int sbrk(int incr); }
+70	AUE_SSTK	STD	{ int sstk(int incr); }
+71	AUE_MMAP	COMPAT	{ int mmap(void *addr, int len, int prot, \
 				    int flags, int fd, long pos); }
-72	AUE_O_VADVISE	MSTD	{ int ovadvise(int anom); } vadvise \
+72	AUE_O_VADVISE	STD	{ int ovadvise(int anom); } vadvise \
 				    ovadvise_args int
-73	AUE_MUNMAP	MSTD	{ int munmap(void *addr, size_t len); }
-74	AUE_MPROTECT	MSTD	{ int mprotect(const void *addr, size_t len, \
+73	AUE_MUNMAP	STD	{ int munmap(void *addr, size_t len); }
+74	AUE_MPROTECT	STD	{ int mprotect(const void *addr, size_t len, \
 				    int prot); }
-75	AUE_MADVISE	MSTD	{ int madvise(void *addr, size_t len, \
+75	AUE_MADVISE	STD	{ int madvise(void *addr, size_t len, \
 				    int behav); }
 76	AUE_NULL	OBSOL	vhangup
 77	AUE_NULL	OBSOL	vlimit
-78	AUE_MINCORE	MSTD	{ int mincore(const void *addr, size_t len, \
+78	AUE_MINCORE	STD	{ int mincore(const void *addr, size_t len, \
 				    char *vec); }
-79	AUE_GETGROUPS	MSTD	{ int getgroups(u_int gidsetsize, \
+79	AUE_GETGROUPS	STD	{ int getgroups(u_int gidsetsize, \
 				    gid_t *gidset); }
-80	AUE_SETGROUPS	MSTD	{ int setgroups(u_int gidsetsize, \
+80	AUE_SETGROUPS	STD	{ int setgroups(u_int gidsetsize, \
 				    gid_t *gidset); }
-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 \
+81	AUE_GETPGRP	STD	{ int getpgrp(void); }
+82	AUE_SETPGRP	STD	{ int setpgid(int pid, int pgid); }
+83	AUE_SETITIMER	STD	{ int setitimer(u_int which, struct \
 				    itimerval *itv, struct itimerval *oitv); }
-84	AUE_WAIT4	MCOMPAT	{ int wait(void); }
-85	AUE_SWAPON	MSTD	{ int swapon(char *name); }
-86	AUE_GETITIMER	MSTD	{ int getitimer(u_int which, \
+84	AUE_WAIT4	COMPAT	{ int wait(void); }
+85	AUE_SWAPON	STD	{ int swapon(char *name); }
+86	AUE_GETITIMER	STD	{ int getitimer(u_int which, \
 				    struct itimerval *itv); }
-87	AUE_SYSCTL	MCOMPAT	{ int gethostname(char *hostname, \
+87	AUE_SYSCTL	COMPAT	{ int gethostname(char *hostname, \
 				    u_int len); } gethostname \
 				    gethostname_args int
-88	AUE_SYSCTL	MCOMPAT	{ int sethostname(char *hostname, \
+88	AUE_SYSCTL	COMPAT	{ int sethostname(char *hostname, \
 				    u_int len); } sethostname \
 				    sethostname_args int
-89	AUE_GETDTABLESIZE	MSTD	{ int getdtablesize(void); }
-90	AUE_DUP2	MSTD	{ int dup2(u_int from, u_int to); }
+89	AUE_GETDTABLESIZE	STD	{ int getdtablesize(void); }
+90	AUE_DUP2	STD	{ int dup2(u_int from, u_int to); }
 91	AUE_NULL	UNIMPL	getdopt
-92	AUE_FCNTL	MSTD	{ int fcntl(int fd, int cmd, long arg); }
+92	AUE_FCNTL	STD	{ 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	MSTD	{ int select(int nd, fd_set *in, fd_set *ou, \
+93	AUE_SELECT	STD	{ int select(int nd, fd_set *in, fd_set *ou, \
 				    fd_set *ex, struct timeval *tv); }
 94	AUE_NULL	UNIMPL	setdopt
-95	AUE_FSYNC	MSTD	{ int fsync(int fd); }
-96	AUE_SETPRIORITY	MSTD	{ int setpriority(int which, int who, \
+95	AUE_FSYNC	STD	{ int fsync(int fd); }
+96	AUE_SETPRIORITY	STD	{ int setpriority(int which, int who, \
 				    int prio); }
-97	AUE_SOCKET	MSTD	{ int socket(int domain, int type, \
+97	AUE_SOCKET	STD	{ int socket(int domain, int type, \
 				    int protocol); }
-98	AUE_CONNECT	MSTD	{ int connect(int s, caddr_t name, \
+98	AUE_CONNECT	STD	{ int connect(int s, caddr_t name, \
 				    int namelen); }
-99	AUE_ACCEPT	MCPT_NOA { int accept(int s, caddr_t name, \
+99	AUE_ACCEPT	CPT_NOA	{ int accept(int s, caddr_t name, \
 				    int *anamelen); } accept accept_args int
-100	AUE_GETPRIORITY	MSTD	{ int getpriority(int which, int who); }
-101	AUE_SEND	MCOMPAT	{ int send(int s, caddr_t buf, int len, \
+100	AUE_GETPRIORITY	STD	{ int getpriority(int which, int who); }
+101	AUE_SEND	COMPAT	{ int send(int s, caddr_t buf, int len, \
 				    int flags); }
-102	AUE_RECV	MCOMPAT	{ int recv(int s, caddr_t buf, int len, \
+102	AUE_RECV	COMPAT	{ int recv(int s, caddr_t buf, int len, \
 				    int flags); }
-103	AUE_SIGRETURN	MCOMPAT	{ int sigreturn( \
+103	AUE_SIGRETURN	COMPAT	{ int sigreturn( \
 				    struct osigcontext *sigcntxp); }
-104	AUE_BIND	MSTD	{ int bind(int s, caddr_t name, \
+104	AUE_BIND	STD	{ int bind(int s, caddr_t name, \
 				    int namelen); }
-105	AUE_SETSOCKOPT	MSTD	{ int setsockopt(int s, int level, int name, \
+105	AUE_SETSOCKOPT	STD	{ int setsockopt(int s, int level, int name, \
 				    caddr_t val, int valsize); }
-106	AUE_LISTEN	MSTD	{ int listen(int s, int backlog); }
+106	AUE_LISTEN	STD	{ int listen(int s, int backlog); }
 107	AUE_NULL	OBSOL	vtimes
-108	AUE_NULL	MCOMPAT	{ int sigvec(int signum, struct sigvec *nsv, \
+108	AUE_NULL	COMPAT	{ 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_NULL	COMPAT	{ int sigblock(int mask); }
+110	AUE_NULL	COMPAT	{ int sigsetmask(int mask); }
+111	AUE_NULL	COMPAT	{ 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_NULL	COMPAT	{ int sigstack(struct sigstack *nss, \
 				    struct sigstack *oss); }
-113	AUE_RECVMSG	MCOMPAT	{ int recvmsg(int s, struct omsghdr *msg, \
+113	AUE_RECVMSG	COMPAT	{ int recvmsg(int s, struct omsghdr *msg, \
 				    int flags); }
-114	AUE_SENDMSG	MCOMPAT	{ int sendmsg(int s, caddr_t msg, \
+114	AUE_SENDMSG	COMPAT	{ int sendmsg(int s, caddr_t msg, \
 				    int flags); }
 115	AUE_NULL	OBSOL	vtrace
-116	AUE_GETTIMEOFDAY	MSTD	{ int gettimeofday(struct timeval *tp, \
+116	AUE_GETTIMEOFDAY	STD	{ int gettimeofday(struct timeval *tp, \
 				    struct timezone *tzp); }
-117	AUE_GETRUSAGE	MSTD	{ int getrusage(int who, \
+117	AUE_GETRUSAGE	STD	{ int getrusage(int who, \
 				    struct rusage *rusage); }
-118	AUE_GETSOCKOPT	MSTD	{ int getsockopt(int s, int level, int name, \
+118	AUE_GETSOCKOPT	STD	{ int getsockopt(int s, int level, int name, \
 				    caddr_t val, int *avalsize); }
 119	AUE_NULL	UNIMPL	resuba (BSD/OS 2.x)
-120	AUE_READV	MSTD	{ int readv(int fd, struct iovec *iovp, \
+120	AUE_READV	STD	{ int readv(int fd, struct iovec *iovp, \
 				    u_int iovcnt); }
-121	AUE_WRITEV	MSTD	{ int writev(int fd, struct iovec *iovp, \
+121	AUE_WRITEV	STD	{ int writev(int fd, struct iovec *iovp, \
 				    u_int iovcnt); }
-122	AUE_SETTIMEOFDAY	MSTD	{ int settimeofday(struct timeval *tv, \
+122	AUE_SETTIMEOFDAY	STD	{ int settimeofday(struct timeval *tv, \
 				    struct timezone *tzp); }
-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, \
+123	AUE_FCHOWN	STD	{ int fchown(int fd, int uid, int gid); }
+124	AUE_FCHMOD	STD	{ int fchmod(int fd, int mode); }
+125	AUE_RECVFROM	CPT_NOA	{ int recvfrom(int s, caddr_t buf, \
 				    size_t len, int flags, caddr_t from, int \
 				    *fromlenaddr); } recvfrom recvfrom_args \
 				    int
-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_TRUNCATE	MCOMPAT	{ int truncate(char *path, long length); }
-130	AUE_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, \
+126	AUE_SETREUID	STD	{ int setreuid(int ruid, int euid); }
+127	AUE_SETREGID	STD	{ int setregid(int rgid, int egid); }
+128	AUE_RENAME	STD	{ int rename(char *from, char *to); }
+129	AUE_TRUNCATE	COMPAT	{ int truncate(char *path, long length); }
+130	AUE_FTRUNCATE	COMPAT	{ int ftruncate(int fd, long length); }
+131	AUE_FLOCK	STD	{ int flock(int fd, int how); }
+132	AUE_MKFIFO	STD	{ int mkfifo(char *path, int mode); }
+133	AUE_SENDTO	STD	{ int sendto(int s, caddr_t buf, size_t len, \
 				    int flags, caddr_t to, int tolen); }
-134	AUE_SHUTDOWN	MSTD	{ int shutdown(int s, int how); }
-135	AUE_SOCKETPAIR	MSTD	{ int socketpair(int domain, int type, \
+134	AUE_SHUTDOWN	STD	{ int shutdown(int s, int how); }
+135	AUE_SOCKETPAIR	STD	{ int socketpair(int domain, int type, \
 				    int protocol, int *rsv); }
-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, \
+136	AUE_MKDIR	STD	{ int mkdir(char *path, int mode); }
+137	AUE_RMDIR	STD	{ int rmdir(char *path); }
+138	AUE_UTIMES	STD	{ int utimes(char *path, \
 				    struct timeval *tptr); }
 139	AUE_NULL	OBSOL	4.2 sigreturn
-140	AUE_ADJTIME	MSTD	{ int adjtime(struct timeval *delta, \
+140	AUE_ADJTIME	STD	{ int adjtime(struct timeval *delta, \
 				    struct timeval *olddelta); }
-141	AUE_GETPEERNAME	MCOMPAT	{ int getpeername(int fdes, caddr_t asa, \
+141	AUE_GETPEERNAME	COMPAT	{ int getpeername(int fdes, caddr_t asa, \
 				    int *alen); }
-142	AUE_SYSCTL	MCOMPAT	{ long gethostid(void); }
-143	AUE_SYSCTL	MCOMPAT	{ int sethostid(long hostid); }
-144	AUE_GETRLIMIT	MCOMPAT	{ int getrlimit(u_int which, struct \
+142	AUE_SYSCTL	COMPAT	{ long gethostid(void); }
+143	AUE_SYSCTL	COMPAT	{ int sethostid(long hostid); }
+144	AUE_GETRLIMIT	COMPAT	{ int getrlimit(u_int which, struct \
 				    orlimit *rlp); }
-145	AUE_SETRLIMIT	MCOMPAT	{ int setrlimit(u_int which, \
+145	AUE_SETRLIMIT	COMPAT	{ int setrlimit(u_int which, \
 				    struct orlimit *rlp); }
-146	AUE_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, \
+146	AUE_KILLPG	COMPAT	{ int killpg(int pgid, int signum); }
+147	AUE_SETSID	STD	{ int setsid(void); }
+148	AUE_QUOTACTL	STD	{ int quotactl(char *path, int cmd, int uid, \
 				    caddr_t arg); }
-149	AUE_O_QUOTA	MCOMPAT	{ int quota(void); }
-150	AUE_GETSOCKNAME	MCPT_NOA	{ int getsockname(int fdec, \
+149	AUE_O_QUOTA	COMPAT	{ int quota(void); }
+150	AUE_GETSOCKNAME	CPT_NOA	{ int getsockname(int fdec, \
 				    caddr_t asa, int *alen); } getsockname \
 				    getsockname_args int
 
@@ -303,95 +299,95 @@
 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_NFSSVC	MNOIMPL	{ int nfssvc(int flag, caddr_t argp); }
-156	AUE_GETDIRENTRIES	MCOMPAT	{ int getdirentries(int fd, char *buf, \
+155	AUE_NFSSVC	NOIMPL	{ int nfssvc(int flag, caddr_t argp); }
+156	AUE_GETDIRENTRIES	COMPAT	{ int getdirentries(int fd, char *buf, \
 				    u_int count, long *basep); }
-157	AUE_STATFS	MCOMPAT4	{ int statfs(char *path, \
+157	AUE_STATFS	COMPAT4	{ int statfs(char *path, \
 				    struct ostatfs *buf); }
-158	AUE_FSTATFS	MCOMPAT4	{ int fstatfs(int fd, \
+158	AUE_FSTATFS	COMPAT4	{ int fstatfs(int fd, \
 				    struct ostatfs *buf); }
 159	AUE_NULL	UNIMPL	nosys
-160	AUE_LGETFH	MSTD	{ int lgetfh(char *fname, \
+160	AUE_LGETFH	STD	{ int lgetfh(char *fname, \
 				    struct fhandle *fhp); }
-161	AUE_NFS_GETFH	MSTD	{ int getfh(char *fname, \
+161	AUE_NFS_GETFH	STD	{ int getfh(char *fname, \
 				    struct fhandle *fhp); }
-162	AUE_SYSCTL	MSTD	{ int getdomainname(char *domainname, \
+162	AUE_SYSCTL	STD	{ int getdomainname(char *domainname, \
 				    int len); }
-163	AUE_SYSCTL	MSTD	{ int setdomainname(char *domainname, \
+163	AUE_SYSCTL	STD	{ 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); }
-166	AUE_NULL	MSTD	{ int rtprio(int function, pid_t pid, \
+164	AUE_NULL	STD	{ int uname(struct utsname *name); }
+165	AUE_NULL	STD	{ int sysarch(int op, char *parms); }
+166	AUE_NULL	STD	{ int rtprio(int function, pid_t pid, \
 				    struct rtprio *rtp); }
 167	AUE_NULL	UNIMPL	nosys
 168	AUE_NULL	UNIMPL	nosys
 ; 169 is initialized by the SYSVSEM code if present or loaded
-169	AUE_SEMSYS	MNOSTD	{ int semsys(int which, int a2, int a3, \
+169	AUE_SEMSYS	NOSTD	{ 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_MSGSYS	MNOSTD	{ int msgsys(int which, int a2, int a3, \
+170	AUE_MSGSYS	NOSTD	{ 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_SHMSYS	MNOSTD	{ int shmsys(int which, int a2, int a3, \
+171	AUE_SHMSYS	NOSTD	{ int shmsys(int which, int a2, int a3, \
 				    int a4); }
 ; XXX should be	{ int shmsys(int which, ...); }
 172	AUE_NULL	UNIMPL	nosys
-173	AUE_PREAD	MSTD	{ ssize_t pread(int fd, void *buf, \
+173	AUE_PREAD	STD	{ ssize_t pread(int fd, void *buf, \
 				    size_t nbyte, int pad, off_t offset); }
-174	AUE_PWRITE	MSTD	{ ssize_t pwrite(int fd, const void *buf, \
+174	AUE_PWRITE	STD	{ ssize_t pwrite(int fd, const void *buf, \
 				    size_t nbyte, int pad, off_t offset); }
 175	AUE_NULL	UNIMPL	nosys
-176	AUE_ADJTIME	MSTD	{ int ntp_adjtime(struct timex *tp); }
+176	AUE_ADJTIME	STD	{ 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_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); }
+181	AUE_SETGID	STD	{ int setgid(gid_t gid); }
+182	AUE_SETEGID	STD	{ int setegid(gid_t egid); }
+183	AUE_SETEUID	STD	{ 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_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); }
+188	AUE_STAT	STD	{ int stat(char *path, struct stat *ub); }
+189	AUE_FSTAT	STD	{ int fstat(int fd, struct stat *sb); }
+190	AUE_LSTAT	STD	{ int lstat(char *path, struct stat *ub); }
+191	AUE_PATHCONF	STD	{ int pathconf(char *path, int name); }
+192	AUE_FPATHCONF	STD	{ int fpathconf(int fd, int name); }
 193	AUE_NULL	UNIMPL	nosys
-194	AUE_GETRLIMIT	MSTD	{ int getrlimit(u_int which, \
+194	AUE_GETRLIMIT	STD	{ int getrlimit(u_int which, \
 				    struct rlimit *rlp); } getrlimit \
 				    __getrlimit_args int
-195	AUE_SETRLIMIT	MSTD	{ int setrlimit(u_int which, \
+195	AUE_SETRLIMIT	STD	{ int setrlimit(u_int which, \
 				    struct rlimit *rlp); } setrlimit \
 				    __setrlimit_args int
-196	AUE_GETDIRENTRIES	MSTD	{ int getdirentries(int fd, char *buf, \
+196	AUE_GETDIRENTRIES	STD	{ int getdirentries(int fd, char *buf, \
 				    u_int count, long *basep); }
-197	AUE_MMAP	MSTD	{ caddr_t mmap(caddr_t addr, size_t len, \
+197	AUE_MMAP	STD	{ 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 \
+198	AUE_NULL	STD	{ int nosys(void); } __syscall \
 				    __syscall_args int
-199	AUE_LSEEK	MSTD	{ off_t lseek(int fd, int pad, off_t offset, \
+199	AUE_LSEEK	STD	{ off_t lseek(int fd, int pad, off_t offset, \
 				    int whence); }
-200	AUE_TRUNCATE	MSTD	{ int truncate(char *path, int pad, \
+200	AUE_TRUNCATE	STD	{ int truncate(char *path, int pad, \
 				    off_t length); }
-201	AUE_FTRUNCATE	MSTD	{ int ftruncate(int fd, int pad, \
+201	AUE_FTRUNCATE	STD	{ int ftruncate(int fd, int pad, \
 				    off_t length); }
-202	AUE_SYSCTL	MSTD	{ int __sysctl(int *name, u_int namelen, \
+202	AUE_SYSCTL	STD	{ int __sysctl(int *name, u_int namelen, \
 				    void *old, size_t *oldlenp, void *new, \
 				    size_t newlen); } __sysctl sysctl_args int
-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); }
+203	AUE_MLOCK	STD	{ int mlock(const void *addr, size_t len); }
+204	AUE_MUNLOCK	STD	{ int munlock(const void *addr, size_t len); }
+205	AUE_UNDELETE	STD	{ int undelete(char *path); }
+206	AUE_FUTIMES	STD	{ int futimes(int fd, struct timeval *tptr); }
+207	AUE_GETPGID	STD	{ int getpgid(pid_t pid); }
 208	AUE_NULL	UNIMPL	newreboot (NetBSD)
-209	AUE_POLL	MSTD	{ int poll(struct pollfd *fds, u_int nfds, \
+209	AUE_POLL	STD	{ int poll(struct pollfd *fds, u_int nfds, \
 				    int timeout); }
 
 ;
@@ -410,44 +406,44 @@
 
 ;
 ; The following were introduced with NetBSD/4.4Lite-2
-220	AUE_SEMCTL	MNOSTD	{ int __semctl(int semid, int semnum, \
+220	AUE_SEMCTL	NOSTD	{ int __semctl(int semid, int semnum, \
 				    int cmd, union semun *arg); }
-221	AUE_SEMGET	MNOSTD	{ int semget(key_t key, int nsems, \
+221	AUE_SEMGET	NOSTD	{ int semget(key_t key, int nsems, \
 				    int semflg); }
-222	AUE_SEMOP	MNOSTD	{ int semop(int semid, struct sembuf *sops, \
+222	AUE_SEMOP	NOSTD	{ int semop(int semid, struct sembuf *sops, \
 				    size_t nsops); }
 223	AUE_NULL	UNIMPL	semconfig
-224	AUE_MSGCTL	MNOSTD	{ int msgctl(int msqid, int cmd, \
+224	AUE_MSGCTL	NOSTD	{ int msgctl(int msqid, int cmd, \
 				    struct msqid_ds *buf); }
-225	AUE_MSGGET	MNOSTD	{ int msgget(key_t key, int msgflg); }
-226	AUE_MSGSND	MNOSTD	{ int msgsnd(int msqid, const void *msgp, \
+225	AUE_MSGGET	NOSTD	{ int msgget(key_t key, int msgflg); }
+226	AUE_MSGSND	NOSTD	{ int msgsnd(int msqid, const void *msgp, \
 				    size_t msgsz, int msgflg); }
-227	AUE_MSGRCV	MNOSTD	{ int msgrcv(int msqid, void *msgp, \
+227	AUE_MSGRCV	NOSTD	{ int msgrcv(int msqid, void *msgp, \
 				    size_t msgsz, long msgtyp, int msgflg); }
-228	AUE_SHMAT	MNOSTD	{ int shmat(int shmid, const void *shmaddr, \
+228	AUE_SHMAT	NOSTD	{ int shmat(int shmid, const void *shmaddr, \
 				    int shmflg); }
-229	AUE_SHMCTL	MNOSTD	{ int shmctl(int shmid, int cmd, \
+229	AUE_SHMCTL	NOSTD	{ int shmctl(int shmid, int cmd, \
 				    struct shmid_ds *buf); }
-230	AUE_SHMDT	MNOSTD	{ int shmdt(const void *shmaddr); }
-231	AUE_SHMGET	MNOSTD	{ int shmget(key_t key, size_t size, \
+230	AUE_SHMDT	NOSTD	{ int shmdt(const void *shmaddr); }
+231	AUE_SHMGET	NOSTD	{ int shmget(key_t key, size_t size, \
 				    int shmflg); }
 ;
-232	AUE_NULL	MSTD	{ int clock_gettime(clockid_t clock_id, \
+232	AUE_NULL	STD	{ int clock_gettime(clockid_t clock_id, \
 				    struct timespec *tp); }
-233	AUE_NULL	MSTD	{ int clock_settime(clockid_t clock_id, \
+233	AUE_NULL	STD	{ int clock_settime(clockid_t clock_id, \
 				    const struct timespec *tp); }
-234	AUE_NULL	MSTD	{ int clock_getres(clockid_t clock_id, \
+234	AUE_NULL	STD	{ int clock_getres(clockid_t clock_id, \
 				    struct timespec *tp); }
-235	AUE_NULL	MSTD	{ int ktimer_create(clockid_t clock_id, \
+235	AUE_NULL	STD	{ int ktimer_create(clockid_t clock_id, \
 				    struct sigevent *evp, int *timerid); }
-236	AUE_NULL	MSTD	{ int ktimer_delete(int timerid); }
-237	AUE_NULL	MSTD	{ int ktimer_settime(int timerid, int flags, \
+236	AUE_NULL	STD	{ int ktimer_delete(int timerid); }
+237	AUE_NULL	STD	{ int ktimer_settime(int timerid, int flags, \
 				    const struct itimerspec *value, \
 				    struct itimerspec *ovalue); }
-238	AUE_NULL	MSTD	{ int ktimer_gettime(int timerid, struct \
+238	AUE_NULL	STD	{ int ktimer_gettime(int timerid, struct \
 				    itimerspec *value); }
-239	AUE_NULL	MSTD	{ int ktimer_getoverrun(int timerid); }
-240	AUE_NULL	MSTD	{ int nanosleep(const struct timespec *rqtp, \
+239	AUE_NULL	STD	{ int ktimer_getoverrun(int timerid); }
+240	AUE_NULL	STD	{ int nanosleep(const struct timespec *rqtp, \
 				    struct timespec *rmtp); }
 241	AUE_NULL	UNIMPL	nosys
 242	AUE_NULL	UNIMPL	nosys
@@ -456,19 +452,19 @@
 245	AUE_NULL	UNIMPL	nosys
 246	AUE_NULL	UNIMPL	nosys
 247	AUE_NULL	UNIMPL	nosys
-248	AUE_NULL	MSTD	{ int ntp_gettime(struct ntptimeval *ntvp); }
+248	AUE_NULL	STD	{ int ntp_gettime(struct ntptimeval *ntvp); }
 249	AUE_NULL	UNIMPL	nosys
 ; syscall numbers initially used in OpenBSD
-250	AUE_MINHERIT	MSTD	{ int minherit(void *addr, size_t len, \
+250	AUE_MINHERIT	STD	{ int minherit(void *addr, size_t len, \
 				    int inherit); }
-251	AUE_RFORK	MSTD	{ int rfork(int flags); }
-252	AUE_POLL	MSTD	{ int openbsd_poll(struct pollfd *fds, \
+251	AUE_RFORK	STD	{ int rfork(int flags); }
+252	AUE_POLL	STD	{ int openbsd_poll(struct pollfd *fds, \
 				    u_int nfds, int timeout); }
-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, \
+253	AUE_ISSETUGID	STD	{ int issetugid(void); }
+254	AUE_LCHOWN	STD	{ int lchown(char *path, int uid, int gid); }
+255	AUE_NULL	NOSTD	{ int aio_read(struct aiocb *aiocbp); }
+256	AUE_NULL	NOSTD	{ int aio_write(struct aiocb *aiocbp); }
+257	AUE_NULL	NOSTD	{ int lio_listio(int mode, \
 				    struct aiocb * const *acb_list, \
 				    int nent, struct sigevent *sig); }
 258	AUE_NULL	UNIMPL	nosys
@@ -485,20 +481,20 @@
 269	AUE_NULL	UNIMPL	nosys
 270	AUE_NULL	UNIMPL	nosys
 271	AUE_NULL	UNIMPL	nosys
-272	AUE_O_GETDENTS	MSTD	{ int getdents(int fd, char *buf, \
+272	AUE_O_GETDENTS	STD	{ int getdents(int fd, char *buf, \
 				    size_t count); }
 273	AUE_NULL	UNIMPL	nosys
-274	AUE_LCHMOD	MSTD	{ int lchmod(char *path, mode_t mode); }
-275	AUE_LCHOWN	MNOPROTO { int lchown(char *path, uid_t uid, \
+274	AUE_LCHMOD	STD	{ int lchmod(char *path, mode_t mode); }
+275	AUE_LCHOWN	NOPROTO	{ int lchown(char *path, uid_t uid, \
 				    gid_t gid); } netbsd_lchown lchown_args \
 				    int
-276	AUE_LUTIMES	MSTD	{ int lutimes(char *path, \
+276	AUE_LUTIMES	STD	{ int lutimes(char *path, \
 				    struct timeval *tptr); }
-277	AUE_MSYNC	MNOPROTO	{ int msync(void *addr, size_t len, \
+277	AUE_MSYNC	NOPROTO	{ int msync(void *addr, size_t len, \
 				    int flags); } netbsd_msync msync_args int
-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); }
+278	AUE_STAT	STD	{ int nstat(char *path, struct nstat *ub); }
+279	AUE_FSTAT	STD	{ int nfstat(int fd, struct nstat *sb); }
+280	AUE_LSTAT	STD	{ int nlstat(char *path, struct nstat *ub); }
 281	AUE_NULL	UNIMPL	nosys
 282	AUE_NULL	UNIMPL	nosys
 283	AUE_NULL	UNIMPL	nosys
@@ -508,9 +504,9 @@
 287	AUE_NULL	UNIMPL	nosys
 288	AUE_NULL	UNIMPL	nosys
 ; 289 and 290 from NetBSD (OpenBSD: 267 and 268)
-289	AUE_NULL	MSTD	{ ssize_t preadv(int fd, struct iovec *iovp, \
+289	AUE_NULL	STD	{ ssize_t preadv(int fd, struct iovec *iovp, \
 					u_int iovcnt, off_t offset); }
-290	AUE_NULL	MSTD	{ ssize_t pwritev(int fd, struct iovec *iovp, \
+290	AUE_NULL	STD	{ ssize_t pwritev(int fd, struct iovec *iovp, \
 					u_int iovcnt, off_t offset); }
 291	AUE_NULL	UNIMPL	nosys
 292	AUE_NULL	UNIMPL	nosys
@@ -519,128 +515,128 @@
 295	AUE_NULL	UNIMPL	nosys
 296	AUE_NULL	UNIMPL	nosys
 ; XXX 297 is 300 in NetBSD 
-297	AUE_FHSTATFS	MCOMPAT4	{ int fhstatfs( \
+297	AUE_FHSTATFS	COMPAT4	{ int fhstatfs( \
 				    const struct fhandle *u_fhp, \
 				    struct ostatfs *buf); }
-298	AUE_FHOPEN	MSTD	{ int fhopen(const struct fhandle *u_fhp, \
+298	AUE_FHOPEN	STD	{ int fhopen(const struct fhandle *u_fhp, \
 				    int flags); }
-299	AUE_FHSTAT	MSTD	{ int fhstat(const struct fhandle *u_fhp, \
+299	AUE_FHSTAT	STD	{ int fhstat(const struct fhandle *u_fhp, \
 				    struct stat *sb); }
 ; syscall numbers for FreeBSD
-300	AUE_NULL	MSTD	{ int modnext(int modid); }
-301	AUE_NULL	MSTD	{ int modstat(int modid, \
+300	AUE_NULL	STD	{ int modnext(int modid); }
+301	AUE_NULL	STD	{ int modstat(int modid, \
 				    struct module_stat *stat); }
-302	AUE_NULL	MSTD	{ int modfnext(int modid); }
-303	AUE_NULL	MSTD	{ int modfind(const char *name); }
-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 \
+302	AUE_NULL	STD	{ int modfnext(int modid); }
+303	AUE_NULL	STD	{ int modfind(const char *name); }
+304	AUE_MODLOAD	STD	{ int kldload(const char *file); }
+305	AUE_MODUNLOAD	STD	{ int kldunload(int fileid); }
+306	AUE_NULL	STD	{ int kldfind(const char *file); }
+307	AUE_NULL	STD	{ int kldnext(int fileid); }
+308	AUE_NULL	STD	{ int kldstat(int fileid, struct \
 				    kld_file_stat* stat); }
-309	AUE_NULL	MSTD	{ int kldfirstmod(int fileid); }
-310	AUE_GETSID	MSTD	{ int getsid(pid_t pid); }
-311	AUE_SETRESUID	MSTD	{ int setresuid(uid_t ruid, uid_t euid, \
+309	AUE_NULL	STD	{ int kldfirstmod(int fileid); }
+310	AUE_GETSID	STD	{ int getsid(pid_t pid); }
+311	AUE_SETRESUID	STD	{ int setresuid(uid_t ruid, uid_t euid, \
 				    uid_t suid); }
-312	AUE_SETRESGID	MSTD	{ int setresgid(gid_t rgid, gid_t egid, \
+312	AUE_SETRESGID	STD	{ 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); }
-315	AUE_NULL	MNOSTD	{ int aio_suspend( \
+314	AUE_NULL	NOSTD	{ int aio_return(struct aiocb *aiocbp); }
+315	AUE_NULL	NOSTD	{ int aio_suspend( \
 				    struct aiocb * const * aiocbp, int nent, \
 				    const struct timespec *timeout); }
-316	AUE_NULL	MNOSTD	{ int aio_cancel(int fd, \
+316	AUE_NULL	NOSTD	{ int aio_cancel(int fd, \
 				    struct aiocb *aiocbp); }
-317	AUE_NULL	MNOSTD	{ int aio_error(struct aiocb *aiocbp); }
-318	AUE_NULL	MNOSTD	{ int oaio_read(struct oaiocb *aiocbp); }
-319	AUE_NULL	MNOSTD	{ int oaio_write(struct oaiocb *aiocbp); }
-320	AUE_NULL	MNOSTD	{ int olio_listio(int mode, \
+317	AUE_NULL	NOSTD	{ int aio_error(struct aiocb *aiocbp); }
+318	AUE_NULL	NOSTD	{ int oaio_read(struct oaiocb *aiocbp); }
+319	AUE_NULL	NOSTD	{ int oaio_write(struct oaiocb *aiocbp); }
+320	AUE_NULL	NOSTD	{ int olio_listio(int mode, \
 				    struct oaiocb * const *acb_list, \
 				    int nent, struct osigevent *sig); }
-321	AUE_NULL	MSTD	{ int yield(void); }
+321	AUE_NULL	STD	{ int yield(void); }
 322	AUE_NULL	OBSOL	thr_sleep
 323	AUE_NULL	OBSOL	thr_wakeup
-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); }
+324	AUE_MLOCKALL	STD	{ int mlockall(int how); }
+325	AUE_MUNLOCKALL	STD	{ int munlockall(void); }
+326	AUE_NULL	STD	{ int __getcwd(u_char *buf, u_int buflen); }
 
-327	AUE_NULL	MSTD	{ int sched_setparam (pid_t pid, \
+327	AUE_NULL	STD	{ int sched_setparam (pid_t pid, \
 				    const struct sched_param *param); }
-328	AUE_NULL	MSTD	{ int sched_getparam (pid_t pid, struct \
+328	AUE_NULL	STD	{ int sched_getparam (pid_t pid, struct \
 				    sched_param *param); }
 
-329	AUE_NULL	MSTD	{ int sched_setscheduler (pid_t pid, int \
+329	AUE_NULL	STD	{ int sched_setscheduler (pid_t pid, int \
 				    policy, const struct sched_param \
 				    *param); }
-330	AUE_NULL	MSTD	{ int sched_getscheduler (pid_t pid); }
+330	AUE_NULL	STD	{ int sched_getscheduler (pid_t pid); }
 
-331	AUE_NULL	MSTD	{ int sched_yield (void); }
-332	AUE_NULL	MSTD	{ int sched_get_priority_max (int policy); }
-333	AUE_NULL	MSTD	{ int sched_get_priority_min (int policy); }
-334	AUE_NULL	MSTD	{ int sched_rr_get_interval (pid_t pid, \
+331	AUE_NULL	STD	{ int sched_yield (void); }
+332	AUE_NULL	STD	{ int sched_get_priority_max (int policy); }
+333	AUE_NULL	STD	{ int sched_get_priority_min (int policy); }
+334	AUE_NULL	STD	{ 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_SENDFILE	MCOMPAT4	{ int sendfile(int fd, int s, \
+335	AUE_NULL	STD	{ int utrace(const void *addr, size_t len); }
+336	AUE_SENDFILE	COMPAT4	{ 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, \
+337	AUE_NULL	STD	{ int kldsym(int fileid, int cmd, \
 				    void *data); }
-338	AUE_JAIL	MSTD	{ int jail(struct jail *jail); }
+338	AUE_JAIL	STD	{ int jail(struct jail *jail); }
 339	AUE_NULL	UNIMPL	pioctl
-340	AUE_SIGPROCMASK	MSTD	{ int sigprocmask(int how, \
+340	AUE_SIGPROCMASK	STD	{ int sigprocmask(int how, \
 				    const sigset_t *set, sigset_t *oset); }
-341	AUE_SIGSUSPEND	MSTD	{ int sigsuspend(const sigset_t *sigmask); }
-342	AUE_SIGACTION	MCOMPAT4	{ int sigaction(int sig, const \
+341	AUE_SIGSUSPEND	STD	{ int sigsuspend(const sigset_t *sigmask); }
+342	AUE_SIGACTION	COMPAT4	{ int sigaction(int sig, const \
 				    struct sigaction *act, \
 				    struct sigaction *oact); }
-343	AUE_SIGPENDING	MSTD	{ int sigpending(sigset_t *set); }
-344	AUE_SIGRETURN	MCOMPAT4	{ int sigreturn( \
+343	AUE_SIGPENDING	STD	{ int sigpending(sigset_t *set); }
+344	AUE_SIGRETURN	COMPAT4	{ int sigreturn( \
 				    const struct ucontext4 *sigcntxp); }
-345	AUE_SIGWAIT	MSTD	{ int sigtimedwait(const sigset_t *set, \
+345	AUE_SIGWAIT	STD	{ int sigtimedwait(const sigset_t *set, \
 				    siginfo_t *info, \
 				    const struct timespec *timeout); }
-346	AUE_NULL	MSTD	{ int sigwaitinfo(const sigset_t *set, \
+346	AUE_NULL	STD	{ int sigwaitinfo(const sigset_t *set, \
 				    siginfo_t *info); }
-347	AUE_NULL	MSTD	{ int __acl_get_file(const char *path, \
+347	AUE_NULL	STD	{ int __acl_get_file(const char *path, \
 				    acl_type_t type, struct acl *aclp); }
-348	AUE_NULL	MSTD	{ int __acl_set_file(const char *path, \
+348	AUE_NULL	STD	{ int __acl_set_file(const char *path, \
 				    acl_type_t type, struct acl *aclp); }
-349	AUE_NULL	MSTD	{ int __acl_get_fd(int filedes, \
+349	AUE_NULL	STD	{ int __acl_get_fd(int filedes, \
 				    acl_type_t type, struct acl *aclp); }
-350	AUE_NULL	MSTD	{ int __acl_set_fd(int filedes, \
+350	AUE_NULL	STD	{ int __acl_set_fd(int filedes, \
 				    acl_type_t type, struct acl *aclp); }
-351	AUE_NULL	MSTD	{ int __acl_delete_file(const char *path, \
+351	AUE_NULL	STD	{ int __acl_delete_file(const char *path, \
 				    acl_type_t type); }
-352	AUE_NULL	MSTD	{ int __acl_delete_fd(int filedes, \
+352	AUE_NULL	STD	{ int __acl_delete_fd(int filedes, \
 				    acl_type_t type); }
-353	AUE_NULL	MSTD	{ int __acl_aclcheck_file(const char *path, \
+353	AUE_NULL	STD	{ int __acl_aclcheck_file(const char *path, \
 				    acl_type_t type, struct acl *aclp); }
-354	AUE_NULL	MSTD	{ int __acl_aclcheck_fd(int filedes, \
+354	AUE_NULL	STD	{ int __acl_aclcheck_fd(int filedes, \
 				    acl_type_t type, struct acl *aclp); }
-355	AUE_EXTATTRCTL	MSTD	{ int extattrctl(const char *path, int cmd, \
+355	AUE_EXTATTRCTL	STD	{ int extattrctl(const char *path, int cmd, \
 				    const char *filename, int attrnamespace, \
 				    const char *attrname); }
-356	AUE_EXTATTR_SET_FILE	MSTD	{ int extattr_set_file( \
+356	AUE_EXTATTR_SET_FILE	STD	{ int extattr_set_file( \
 				    const char *path, int attrnamespace, \
 				    const char *attrname, void *data, \
 				    size_t nbytes); }
-357	AUE_EXTATTR_GET_FILE	MSTD	{ ssize_t extattr_get_file( \
+357	AUE_EXTATTR_GET_FILE	STD	{ ssize_t extattr_get_file( \
 				    const char *path, int attrnamespace, \
 				    const char *attrname, void *data, \
 				    size_t nbytes); }
-358	AUE_EXTATTR_DELETE_FILE	MSTD	{ int extattr_delete_file(const char *path, \
+358	AUE_EXTATTR_DELETE_FILE	STD	{ int extattr_delete_file(const char *path, \
 				    int attrnamespace, \
 				    const char *attrname); }
-359	AUE_NULL	MNOSTD	{ int aio_waitcomplete( \
+359	AUE_NULL	NOSTD	{ int aio_waitcomplete( \
 				    struct aiocb **aiocbp, \
 				    struct timespec *timeout); }
-360	AUE_GETRESUID	MSTD	{ int getresuid(uid_t *ruid, uid_t *euid, \
+360	AUE_GETRESUID	STD	{ int getresuid(uid_t *ruid, uid_t *euid, \
 				    uid_t *suid); }
-361	AUE_GETRESGID	MSTD	{ int getresgid(gid_t *rgid, gid_t *egid, \
+361	AUE_GETRESGID	STD	{ 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, \
+362	AUE_NULL	STD	{ int kqueue(void); }
+363	AUE_NULL	STD	{ int kevent(int fd, \
 				    struct kevent *changelist, int nchanges, \
 				    struct kevent *eventlist, int nevents, \
 				    const struct timespec *timeout); }
@@ -651,184 +647,184 @@
 368	AUE_NULL	UNIMPL	__cap_set_fd
 369	AUE_NULL	UNIMPL	__cap_set_file
 370	AUE_NULL	NODEF	lkmressys lkmressys nosys_args int
-371	AUE_EXTATTR_SET_FD	MSTD	{ int extattr_set_fd(int fd, \
+371	AUE_EXTATTR_SET_FD	STD	{ int extattr_set_fd(int fd, \
 				    int attrnamespace, const char *attrname, \
 				    void *data, size_t nbytes); }
-372	AUE_EXTATTR_GET_FD	MSTD	{ ssize_t extattr_get_fd(int fd, \
+372	AUE_EXTATTR_GET_FD	STD	{ ssize_t extattr_get_fd(int fd, \
 				    int attrnamespace, const char *attrname, \
 				    void *data, size_t nbytes); }
-373	AUE_EXTATTR_DELETE_FD	MSTD	{ int extattr_delete_fd(int fd, \
+373	AUE_EXTATTR_DELETE_FD	STD	{ int extattr_delete_fd(int fd, \
 				    int attrnamespace, \
 				    const char *attrname); }
-374	AUE_NULL	MSTD	{ int __setugid(int flag); }
+374	AUE_NULL	STD	{ int __setugid(int flag); }
 375	AUE_NULL	NOIMPL	{ int nfsclnt(int flag, caddr_t argp); }
-376	AUE_EACCESS	MSTD	{ int eaccess(char *path, int flags); }
+376	AUE_EACCESS	STD	{ int eaccess(char *path, int flags); }
 377	AUE_NULL	UNIMPL	afs_syscall
-378	AUE_NMOUNT	MSTD	{ int nmount(struct iovec *iovp, \
+378	AUE_NMOUNT	STD	{ int nmount(struct iovec *iovp, \
 				    unsigned int iovcnt, int flags); }
-379	AUE_NULL	MSTD	{ int kse_exit(void); }
-380	AUE_NULL	MSTD	{ int kse_wakeup(struct kse_mailbox *mbx); }
-381	AUE_NULL	MSTD	{ int kse_create(struct kse_mailbox *mbx, \
+379	AUE_NULL	STD	{ int kse_exit(void); }
+380	AUE_NULL	STD	{ int kse_wakeup(struct kse_mailbox *mbx); }
+381	AUE_NULL	STD	{ int kse_create(struct kse_mailbox *mbx, \
 				    int newgroup); }
-382	AUE_NULL	MSTD	{ int kse_thr_interrupt( \
+382	AUE_NULL	STD	{ int kse_thr_interrupt( \
 				    struct kse_thr_mailbox *tmbx, int cmd, \
 				    long data); }
-383	AUE_NULL	MSTD	{ int kse_release(struct timespec *timeout); }
-384	AUE_NULL	MSTD	{ int __mac_get_proc(struct mac *mac_p); }
-385	AUE_NULL	MSTD	{ int __mac_set_proc(struct mac *mac_p); }
-386	AUE_NULL	MSTD	{ int __mac_get_fd(int fd, \
+383	AUE_NULL	STD	{ int kse_release(struct timespec *timeout); }
+384	AUE_NULL	STD	{ int __mac_get_proc(struct mac *mac_p); }
+385	AUE_NULL	STD	{ int __mac_set_proc(struct mac *mac_p); }
+386	AUE_NULL	STD	{ int __mac_get_fd(int fd, \
 				    struct mac *mac_p); }
-387	AUE_NULL	MSTD	{ int __mac_get_file(const char *path_p, \
+387	AUE_NULL	STD	{ int __mac_get_file(const char *path_p, \
 				    struct mac *mac_p); }
-388	AUE_NULL	MSTD	{ int __mac_set_fd(int fd, \
+388	AUE_NULL	STD	{ int __mac_set_fd(int fd, \
 				    struct mac *mac_p); }
-389	AUE_NULL	MSTD	{ int __mac_set_file(const char *path_p, \
+389	AUE_NULL	STD	{ int __mac_set_file(const char *path_p, \
 				    struct mac *mac_p); }
-390	AUE_NULL	MSTD	{ int kenv(int what, const char *name, \
+390	AUE_NULL	STD	{ int kenv(int what, const char *name, \
 				    char *value, int len); }
-391	AUE_LCHFLAGS	MSTD	{ int lchflags(const char *path, int flags); }
-392	AUE_NULL	MSTD	{ int uuidgen(struct uuid *store, \
+391	AUE_LCHFLAGS	STD	{ int lchflags(const char *path, int flags); }
+392	AUE_NULL	STD	{ int uuidgen(struct uuid *store, \
 				    int count); }
-393	AUE_SENDFILE	MSTD	{ int sendfile(int fd, int s, off_t offset, \
+393	AUE_SENDFILE	STD	{ 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, \
+394	AUE_NULL	STD	{ int mac_syscall(const char *policy, \
 				    int call, void *arg); }
-395	AUE_GETFSSTAT	MSTD	{ int getfsstat(struct statfs *buf, \
+395	AUE_GETFSSTAT	STD	{ int getfsstat(struct statfs *buf, \
 				    long bufsize, int flags); }
-396	AUE_STATFS	MSTD	{ int statfs(char *path, \
+396	AUE_STATFS	STD	{ int statfs(char *path, \
 				    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, \
+397	AUE_FSTATFS	STD	{ int fstatfs(int fd, struct statfs *buf); }
+398	AUE_NULL	STD	{ int fhstatfs(const struct fhandle *u_fhp, \
 				    struct statfs *buf); }
 399	AUE_NULL	UNIMPL	nosys
-400	AUE_NULL	MNOSTD	{ int ksem_close(semid_t id); }
-401	AUE_NULL	MNOSTD	{ int ksem_post(semid_t id); }
-402	AUE_NULL	MNOSTD	{ int ksem_wait(semid_t id); }
-403	AUE_NULL	MNOSTD	{ int ksem_trywait(semid_t id); }
-404	AUE_NULL	MNOSTD	{ int ksem_init(semid_t *idp, \
+400	AUE_NULL	NOSTD	{ int ksem_close(semid_t id); }
+401	AUE_NULL	NOSTD	{ int ksem_post(semid_t id); }
+402	AUE_NULL	NOSTD	{ int ksem_wait(semid_t id); }
+403	AUE_NULL	NOSTD	{ int ksem_trywait(semid_t id); }
+404	AUE_NULL	NOSTD	{ int ksem_init(semid_t *idp, \
 				    unsigned int value); }
-405	AUE_NULL	MNOSTD	{ int ksem_open(semid_t *idp, \
+405	AUE_NULL	NOSTD	{ int ksem_open(semid_t *idp, \
 				    const char *name, int oflag, \
 				    mode_t mode, unsigned int value); }
-406	AUE_NULL	MNOSTD	{ int ksem_unlink(const char *name); }
-407	AUE_NULL	MNOSTD	{ int ksem_getvalue(semid_t id, int *val); }
-408	AUE_NULL	MNOSTD	{ int ksem_destroy(semid_t id); }
-409	AUE_NULL	MSTD	{ int __mac_get_pid(pid_t pid, \
+406	AUE_NULL	NOSTD	{ int ksem_unlink(const char *name); }
+407	AUE_NULL	NOSTD	{ int ksem_getvalue(semid_t id, int *val); }
+408	AUE_NULL	NOSTD	{ int ksem_destroy(semid_t id); }
+409	AUE_NULL	STD	{ int __mac_get_pid(pid_t pid, \
 				    struct mac *mac_p); }
-410	AUE_NULL	MSTD	{ int __mac_get_link(const char *path_p, \
+410	AUE_NULL	STD	{ int __mac_get_link(const char *path_p, \
 				    struct mac *mac_p); }
-411	AUE_NULL	MSTD	{ int __mac_set_link(const char *path_p, \
+411	AUE_NULL	STD	{ int __mac_set_link(const char *path_p, \
 				    struct mac *mac_p); }
-412	AUE_EXTATTR_SET_LINK	MSTD	{ int extattr_set_link( \
+412	AUE_EXTATTR_SET_LINK	STD	{ int extattr_set_link( \
 				    const char *path, int attrnamespace, \
 				    const char *attrname, void *data, \
 				    size_t nbytes); }
-413	AUE_EXTATTR_GET_LINK	MSTD	{ ssize_t extattr_get_link( \
+413	AUE_EXTATTR_GET_LINK	STD	{ ssize_t extattr_get_link( \
 				    const char *path, int attrnamespace, \
 				    const char *attrname, void *data, \
 				    size_t nbytes); }
-414	AUE_EXTATTR_DELETE_LINK	MSTD	{ int extattr_delete_link( \
+414	AUE_EXTATTR_DELETE_LINK	STD	{ int extattr_delete_link( \
 				    const char *path, int attrnamespace, \
 				    const char *attrname); }
-415	AUE_NULL	MSTD	{ int __mac_execve(char *fname, char **argv, \
+415	AUE_NULL	STD	{ int __mac_execve(char *fname, char **argv, \
 				    char **envv, struct mac *mac_p); }
-416	AUE_SIGACTION	MSTD	{ int sigaction(int sig, \
+416	AUE_SIGACTION	STD	{ int sigaction(int sig, \
 				    const struct sigaction *act, \
 				    struct sigaction *oact); }
-417	AUE_SIGRETURN	MSTD	{ int sigreturn( \
+417	AUE_SIGRETURN	STD	{ int sigreturn( \
 				    const struct __ucontext *sigcntxp); }
 418	AUE_NULL	UNIMPL	__xstat
 419	AUE_NULL	UNIMPL	__xfstat
 420	AUE_NULL	UNIMPL	__xlstat
-421	AUE_NULL	MSTD	{ int getcontext(struct __ucontext *ucp); }
-422	AUE_NULL	MSTD	{ int setcontext( \
+421	AUE_NULL	STD	{ int getcontext(struct __ucontext *ucp); }
+422	AUE_NULL	STD	{ int setcontext( \
 				    const struct __ucontext *ucp); }
-423	AUE_NULL	MSTD	{ int swapcontext(struct __ucontext *oucp, \
+423	AUE_NULL	STD	{ int swapcontext(struct __ucontext *oucp, \
 				    const struct __ucontext *ucp); }
-424	AUE_SWAPOFF	MSTD	{ int swapoff(const char *name); }
-425	AUE_NULL	MSTD	{ int __acl_get_link(const char *path, \
+424	AUE_SWAPOFF	STD	{ int swapoff(const char *name); }
+425	AUE_NULL	STD	{ 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, \
+426	AUE_NULL	STD	{ int __acl_set_link(const char *path, \
 				    acl_type_t type, struct acl *aclp); }
-427	AUE_NULL	MSTD	{ int __acl_delete_link(const char *path, \
+427	AUE_NULL	STD	{ int __acl_delete_link(const char *path, \
 				    acl_type_t type); }
-428	AUE_NULL	MSTD	{ int __acl_aclcheck_link(const char *path, \
+428	AUE_NULL	STD	{ int __acl_aclcheck_link(const char *path, \
 				    acl_type_t type, struct acl *aclp); }
-429	AUE_SIGWAIT	MSTD	{ int sigwait(const sigset_t *set, \
+429	AUE_SIGWAIT	STD	{ int sigwait(const sigset_t *set, \
 				    int *sig); }
-430	AUE_NULL	MSTD	{ int thr_create(ucontext_t *ctx, long *id, \
+430	AUE_NULL	STD	{ int thr_create(ucontext_t *ctx, long *id, \
 				    int flags); }
-431	AUE_NULL	MSTD	{ void thr_exit(long *state); }
-432	AUE_NULL	MSTD	{ int thr_self(long *id); }
-433	AUE_NULL	MSTD	{ int thr_kill(long id, int sig); }
-434	AUE_NULL	MSTD	{ int _umtx_lock(struct umtx *umtx); }
-435	AUE_NULL	MSTD	{ int _umtx_unlock(struct umtx *umtx); }
-436	AUE_NULL	MSTD	{ int jail_attach(int jid); }
-437	AUE_EXTATTR_LIST_FD	MSTD	{ ssize_t extattr_list_fd(int fd, \
+431	AUE_NULL	STD	{ void thr_exit(long *state); }
+432	AUE_NULL	STD	{ int thr_self(long *id); }
+433	AUE_NULL	STD	{ int thr_kill(long id, int sig); }
+434	AUE_NULL	STD	{ int _umtx_lock(struct umtx *umtx); }
+435	AUE_NULL	STD	{ int _umtx_unlock(struct umtx *umtx); }
+436	AUE_NULL	STD	{ int jail_attach(int jid); }
+437	AUE_EXTATTR_LIST_FD	STD	{ ssize_t extattr_list_fd(int fd, \
 				    int attrnamespace, void *data, \
 				    size_t nbytes); }
-438	AUE_EXTATTR_LIST_FILE	MSTD	{ ssize_t extattr_list_file( \
+438	AUE_EXTATTR_LIST_FILE	STD	{ ssize_t extattr_list_file( \
 				    const char *path, int attrnamespace, \
 				    void *data, size_t nbytes); }
-439	AUE_EXTATTR_LIST_LINK	MSTD	{ ssize_t extattr_list_link( \
+439	AUE_EXTATTR_LIST_LINK	STD	{ ssize_t extattr_list_link( \
 				    const char *path, int attrnamespace, \
 				    void *data, size_t nbytes); }
-440	AUE_NULL	MSTD	{ int kse_switchin( \
+440	AUE_NULL	STD	{ int kse_switchin( \
 				    struct kse_thr_mailbox *tmbx, \
 				    int flags); }
-441	AUE_NULL	MNOSTD	{ int ksem_timedwait(semid_t id, \
+441	AUE_NULL	NOSTD	{ int ksem_timedwait(semid_t id, \
 				    const struct timespec *abstime); }
-442	AUE_NULL	MSTD	{ int thr_suspend( \
+442	AUE_NULL	STD	{ int thr_suspend( \
 				    const struct timespec *timeout); }
-443	AUE_NULL	MSTD	{ int thr_wake(long id); }
-444	AUE_NULL	MSTD	{ int kldunloadf(int fileid, int flags); }
-445	AUE_AUDIT	MSTD	{ int audit(const void *record, \
+443	AUE_NULL	STD	{ int thr_wake(long id); }
+444	AUE_NULL	STD	{ int kldunloadf(int fileid, int flags); }
+445	AUE_AUDIT	STD	{ int audit(const void *record, \
 				    u_int length); }
-446	AUE_AUDITON	MSTD	{ int auditon(int cmd, void *data, \
+446	AUE_AUDITON	STD	{ int auditon(int cmd, void *data, \
 				    u_int length); }
-447	AUE_GETAUID	MSTD	{ int getauid(uid_t *auid); }
-448	AUE_SETAUID	MSTD	{ int setauid(uid_t *auid); }
-449	AUE_GETAUDIT	MSTD	{ int getaudit(struct auditinfo *auditinfo); }
-450	AUE_SETAUDIT	MSTD	{ int setaudit(struct auditinfo *auditinfo); }
-451	AUE_GETAUDIT_ADDR	MSTD	{ int getaudit_addr( \
+447	AUE_GETAUID	STD	{ int getauid(uid_t *auid); }
+448	AUE_SETAUID	STD	{ int setauid(uid_t *auid); }
+449	AUE_GETAUDIT	STD	{ int getaudit(struct auditinfo *auditinfo); }
+450	AUE_SETAUDIT	STD	{ int setaudit(struct auditinfo *auditinfo); }
+451	AUE_GETAUDIT_ADDR	STD	{ int getaudit_addr( \
 				    struct auditinfo_addr *auditinfo_addr, \
 				    u_int length); }
-452	AUE_SETAUDIT_ADDR	MSTD	{ int setaudit_addr( \
+452	AUE_SETAUDIT_ADDR	STD	{ int setaudit_addr( \
 				    struct auditinfo_addr *auditinfo_addr, \
 				    u_int length); }
-453	AUE_AUDITCTL	MSTD	{ int auditctl(char *path); }
-454	AUE_NULL	MSTD	{ int _umtx_op(struct umtx *umtx, int op, \
+453	AUE_AUDITCTL	STD	{ int auditctl(char *path); }
+454	AUE_NULL	STD	{ int _umtx_op(struct umtx *umtx, int op, \
 				    long id, void *uaddr, void *uaddr2); }
-455	AUE_NULL	MSTD	{ int thr_new(struct thr_param *param, \
+455	AUE_NULL	STD	{ int thr_new(struct thr_param *param, \
 				    int param_size); }
-456	AUE_NULL	MSTD	{ int sigqueue(pid_t pid, int signum, void *value); }
-457	AUE_NULL	MNOSTD	{ int kmq_open(const char *path, int flags, \
+456	AUE_NULL	STD	{ int sigqueue(pid_t pid, int signum, void *value); }
+457	AUE_NULL	NOSTD	{ int kmq_open(const char *path, int flags, \
 				    mode_t mode, const struct mq_attr *attr); }
-458	AUE_NULL	MNOSTD	{ int kmq_setattr(int mqd,		\
+458	AUE_NULL	NOSTD	{ int kmq_setattr(int mqd,		\
 				    const struct mq_attr *attr,		\
 				    struct mq_attr *oattr); }
-459	AUE_NULL	MNOSTD	{ int kmq_timedreceive(int mqd,	\
+459	AUE_NULL	NOSTD	{ int kmq_timedreceive(int mqd,	\
 				    char *msg_ptr, size_t msg_len,	\
 				    unsigned *msg_prio,			\
 				    const struct timespec *abs_timeout); }
-460	AUE_NULL	MNOSTD  { int kmq_timedsend(int mqd,		\
+460	AUE_NULL	NOSTD	{ int kmq_timedsend(int mqd,		\
 				    const char *msg_ptr, size_t msg_len,\
 				    unsigned msg_prio,			\
 				    const struct timespec *abs_timeout);}
-461	AUE_NULL	MNOSTD	{ int kmq_notify(int mqd,		\
+461	AUE_NULL	NOSTD	{ int kmq_notify(int mqd,		\
 				    const struct sigevent *sigev); }
-462	AUE_NULL	MNOSTD	{ int kmq_unlink(const char *path); }
-463	AUE_NULL	MSTD	{ int abort2(const char *why, int nargs, void **args); }
-464	AUE_NULL	MSTD	{ int thr_set_name(long id, const char *name); }
-465	AUE_NULL	MNOSTD	{ int aio_fsync(int op, struct aiocb *aiocbp); }
-466	AUE_NULL	MSTD	{ int thr_setscheduler(long id, int policy,\
+462	AUE_NULL	NOSTD	{ int kmq_unlink(const char *path); }
+463	AUE_NULL	STD	{ int abort2(const char *why, int nargs, void **args); }
+464	AUE_NULL	STD	{ int thr_set_name(long id, const char *name); }
+465	AUE_NULL	NOSTD	{ int aio_fsync(int op, struct aiocb *aiocbp); }
+466	AUE_NULL	STD	{ int thr_setscheduler(long id, int policy,\
 				    const struct sched_param *param, \
 				    int param_size); }
-467	AUE_NULL	MSTD	{ int thr_getscheduler(long id, int *policy,\
+467	AUE_NULL	STD	{ int thr_getscheduler(long id, int *policy,\
 				    struct sched_param *param, \
 				    int param_size); }
-468	AUE_NULL	MSTD	{ int thr_setschedparam(long id, \
+468	AUE_NULL	STD	{ int thr_setschedparam(long id, \
 				    const struct sched_param *param, \
 				    int param_size); }
 ; Please copy any additions and changes to the following compatability tables: