diff --git a/sys/amd64/linux/syscalls.master b/sys/amd64/linux/syscalls.master
index 0cac26337ef1..4762a2ccc6a5 100644
--- a/sys/amd64/linux/syscalls.master
+++ b/sys/amd64/linux/syscalls.master
@@ -1,2110 +1,2110 @@
  $FreeBSD$
 
 ;	@(#)syscalls.master	8.1 (Berkeley) 7/19/93
 ; System call name/number master file (or rather, slave, from LINUX).
 ; Processed to create linux_sysent.c, linux_proto.h and linux_syscall.h.
 
 ; Columns: number audit type nargs name alt{name,tag,rtyp}/comments
 ;	number	system call number, must be in order
 ;	audit	the audit event associated with the system call
 ;		A value of AUE_NULL means no auditing, but it also means that
 ;		there is no audit event for the call at this time. For the
 ;		case where the event exists, but we don't want auditing, the
 ;		event should be #defined to AUE_NULL in audit_kevents.h.
 ;	type	one of STD, NOPROTO, UNIMPL
 ;	name	pseudo-prototype of syscall routine
 ;		If one of the following alts is different, then all appear:
 ;	altname	name of system call if different
 ;	alttag	name of args struct tag if different from [o]`name'"_args"
 ;	altrtyp	return type if not int (bogus - syscalls always return int)
 ;		for UNIMPL, name continues with comments
 
 ; types:
 ;	STD	always included
 ;	UNIMPL	not implemented, placeholder only
 ;	NOPROTO	same as STD except do not create structure or
 ;		function prototype in sys/sysproto.h.  Does add a
 ;		definition to syscall.h besides adding a sysent.
 
 #include <sys/param.h>
 #include <sys/sysent.h>
 #include <sys/sysproto.h>
 #include <compat/linux/linux_sysproto.h>
 #include <amd64/linux/linux.h>
 #include <amd64/linux/linux_proto.h>
 
 ; Isn't pretty, but there seems to be no other way to trap nosys
 #define	nosys	linux_nosys
 
 ; #ifdef's, etc. may be included, and are copied to the output files.
 
 0	AUE_NULL	NOPROTO {
 		int read(
 		    int fd,
 		    char *buf,
 		    l_size_t nbyte
 		);
 	}
 1	AUE_NULL	NOPROTO {
 		int write(
 		    int fd,
 		    char *buf,
 		    l_size_t nbyte
 		);
 	}
 2	AUE_OPEN_RWTC	STD {
 		int linux_open(
 		    char *path,
 		    l_int flags,
 		    l_mode_t mode
 		);
 	}
 3	AUE_CLOSE	NOPROTO {
 		int close(
 		    int fd
 		);
 	}
 4	AUE_STAT	STD {
 		int linux_newstat(
 		    char *path,
 		    struct l_newstat *buf
 		);
 	}
 5	AUE_FSTAT	STD {
 		int linux_newfstat(
 		    l_uint fd,
 		    struct l_newstat *buf
 		);
 	}
 6	AUE_LSTAT	STD {
 		int linux_newlstat(
 		    char *path,
 		    struct l_newstat *buf
 		);
 	}
-7	AUE_POLL	NOPROTO {
-		int poll(
+7	AUE_POLL	STD {
+		int linux_poll(
 		    struct pollfd *fds,
 		    u_int nfds,
 		    int timeout
 		);
 	}
 8	AUE_LSEEK	STD {
 		int linux_lseek(
 		    l_uint fdes,
 		    l_off_t off,
 		    l_int whence
 		);
 	}
 9	AUE_MMAP	STD {
 		int linux_mmap2(
 		    l_ulong addr,
 		    l_ulong len,
 		    l_ulong prot,
 		    l_ulong flags,
 		    l_ulong fd,
 		    l_ulong pgoff
 		);
 	}
 10	AUE_MPROTECT	STD {
 		int linux_mprotect(
 		    l_ulong addr,
 		    l_size_t len,
 		    l_ulong prot
 		);
 	}
 11	AUE_MUNMAP	NOPROTO {
 		int munmap(
 		    void *addr,
 		    l_size_t len
 		);
 	}
 12	AUE_NULL	STD {
 		int linux_brk(
 		    l_ulong dsend
 		);
 	}
 13	AUE_NULL	STD {
 		int linux_rt_sigaction(
 		    l_int sig,
 		    l_sigaction_t *act,
 		    l_sigaction_t *oact,
 		    l_size_t sigsetsize
 		);
 	}
 14	AUE_NULL	STD {
 		int linux_rt_sigprocmask(
 		    l_int how,
 		    l_sigset_t *mask,
 		    l_sigset_t *omask,
 		    l_size_t sigsetsize
 		);
 	}
 15	AUE_NULL	STD {
 		int linux_rt_sigreturn(
 		    struct l_ucontext *ucp
 		);
 	}
 16	AUE_IOCTL	STD {
 		int linux_ioctl(
 		    l_uint fd,
 		    l_uint cmd,
 		    l_ulong arg
 		);
 	}
 17	AUE_PREAD	STD {
 		int linux_pread(
 		    l_uint fd,
 		    char *buf,
 		    l_size_t nbyte,
 		    l_loff_t offset
 		);
 	}
 18	AUE_PWRITE	STD {
 		int linux_pwrite(
 		    l_uint fd,
 		    char *buf,
 		    l_size_t nbyte,
 		    l_loff_t offset
 		);
 	}
 19	AUE_READV	NOPROTO {
 		int readv(
 		    int fd,
 		    struct iovec *iovp,
 		    u_int iovcnt
 		);
 	}
 20	AUE_WRITEV	NOPROTO {
 		int writev(
 		    int fd,
 		    struct iovec *iovp,
 		    u_int iovcnt
 		);
 	}
 21	AUE_ACCESS	STD {
 		int linux_access(
 		    char *path,
 		    l_int amode
 		);
 	}
 22	AUE_PIPE	STD {
 		int linux_pipe(
 		    l_int *pipefds
 		);
 	}
 23	AUE_SELECT	STD {
 		int linux_select(
 		    l_int nfds,
 		    l_fd_set *readfds,
 		    l_fd_set *writefds,
 		    l_fd_set *exceptfds,
 		    struct l_timeval *timeout
 		);
 	}
 24	AUE_NULL	NOPROTO {
 		int sched_yield(void);
 	}
 25	AUE_NULL	STD {
 		int linux_mremap(
 		    l_ulong addr,
 		    l_ulong old_len,
 		    l_ulong new_len,
 		    l_ulong flags,
 		    l_ulong new_addr
 		);
 	}
 26	AUE_MSYNC	STD {
 		int linux_msync(
 		    l_ulong addr,
 		    l_size_t len,
 		    l_int fl
 		);
 	}
 27	AUE_MINCORE	STD {
 		int linux_mincore(
 		    l_ulong start,
 		    l_size_t len,
 		    u_char *vec
 		);
 	}
 28	AUE_MADVISE	STD {
 		int linux_madvise(
 		    l_ulong addr,
 		    l_size_t len,
 		    l_int behav
 		);
 	}
 29	AUE_NULL	STD {
 		int linux_shmget(
 		    l_key_t key,
 		    l_size_t size,
 		    l_int shmflg
 		);
 	}
 30	AUE_NULL	STD {
 		int linux_shmat(
 		    l_int shmid,
 		    char *shmaddr,
 		    l_int shmflg
 		);
 	}
 31	AUE_NULL	STD {
 		int linux_shmctl(
 		    l_int shmid,
 		    l_int cmd,
 		    struct l_shmid_ds *buf
 		);
 	}
 32	AUE_DUP		NOPROTO {
 		int dup(
 		    u_int fd
 		);
 	}
 33	AUE_DUP2	NOPROTO {
 		int dup2(
 		    u_int from,
 		    u_int to
 		);
 	}
 34	AUE_NULL	STD {
 		int linux_pause(void);
 	}
 35	AUE_NULL	STD {
 		int linux_nanosleep(
 		    const struct l_timespec *rqtp,
 		    struct l_timespec *rmtp
 		);
 	}
 36	AUE_GETITIMER	STD {
 		int linux_getitimer(
 		    l_int which,
 		    struct l_itimerval *itv
 		);
 	}
 37	AUE_NULL	STD {
 		int linux_alarm(
 		    l_uint secs
 		);
 	}
 38	AUE_SETITIMER	STD {
 		int linux_setitimer(
 		    l_int which,
 		    struct l_itimerval *itv,
 		    struct l_itimerval *oitv
 		);
 	}
 39	AUE_GETPID	STD {
 		int linux_getpid(void);
 	}
 40	AUE_SENDFILE	STD {
 		int linux_sendfile(
 		    l_int out,
 		    l_int in,
 		    l_off_t *offset,
 		    l_size_t count
 		);
 	}
 41	AUE_SOCKET	STD {
 		int linux_socket(
 		    l_int domain,
 		    l_int type,
 		    l_int protocol
 		);
 	}
 42	AUE_CONNECT	STD {
 		int linux_connect(
 		    l_int s,
 		    l_uintptr_t name,
 		    l_int namelen
 		);
 	}
 43	AUE_ACCEPT	STD {
 		int linux_accept(
 		    l_int s,
 		    l_uintptr_t addr,
 		    l_uintptr_t namelen
 		);
 	}
 44	AUE_SENDTO	STD {
 		int linux_sendto(
 		    l_int s,
 		    l_uintptr_t msg,
 		    l_size_t len,
 		    l_uint flags,
 		    l_uintptr_t to,
 		    l_int tolen
 		);
 	}
 45	AUE_RECVFROM	STD {
 		int linux_recvfrom(
 		    l_int s,
 		    l_uintptr_t buf,
 		    l_size_t len,
 		    l_uint flags,
 		    l_uintptr_t from,
 		    l_uintptr_t fromlen
 		);
 	}
 46	AUE_SENDMSG	STD {
 		int linux_sendmsg(
 		    l_int s,
 		    l_uintptr_t msg,
 		    l_uint flags
 		);
 	}
 47	AUE_RECVMSG	STD {
 		int linux_recvmsg(
 		    l_int s,
 		    l_uintptr_t msg,
 		    l_uint flags
 		);
 	}
 48	AUE_NULL	STD {
 		int linux_shutdown(
 		    l_int s,
 		    l_int how
 		);
 	}
 49	AUE_BIND	STD {
 		int linux_bind(
 		    l_int s,
 		    l_uintptr_t name,
 		    l_int namelen
 		);
 	}
 50	AUE_LISTEN	STD {
 		int linux_listen(
 		    l_int s,
 		    l_int backlog
 		);
 	}
 51	AUE_GETSOCKNAME	STD {
 		int linux_getsockname(
 		    l_int s,
 		    l_uintptr_t addr,
 		    l_uintptr_t namelen
 		);
 	}
 52	AUE_GETPEERNAME	STD {
 		int linux_getpeername(
 		    l_int s,
 		    l_uintptr_t addr,
 		    l_uintptr_t namelen
 		);
 	}
 53	AUE_SOCKETPAIR	STD {
 		int linux_socketpair(
 		    l_int domain,
 		    l_int type,
 		    l_int protocol,
 		    l_uintptr_t rsv
 		);
 	}
 54	AUE_SETSOCKOPT	STD {
 		int linux_setsockopt(
 		    l_int s,
 		    l_int level,
 		    l_int optname,
 		    l_uintptr_t optval,
 		    l_int optlen
 		);
 	}
 55	AUE_GETSOCKOPT	STD {
 		int linux_getsockopt(
 		    l_int s,
 		    l_int level,
 		    l_int optname,
 		    l_uintptr_t optval,
 		    l_uintptr_t optlen
 		);
 	}
 56	AUE_RFORK	STD {
 		int linux_clone(
 		    l_ulong flags,
 		    void *stack,
 		    void *parent_tidptr,
 		    void *child_tidptr,
 		    void *tls
 		);
 	}
 57	AUE_FORK	STD {
 		int linux_fork(void);
 	}
 58	AUE_VFORK	STD {
 		int linux_vfork(void);
 	}
 59	AUE_EXECVE	STD {
 		int linux_execve(
 		    char *path,
 		    char **argp,
 		    char **envp
 		);
 	}
 60	AUE_EXIT	STD {
 		void linux_exit(
 		    l_int rval
 		);
 	}
 61	AUE_WAIT4	STD {
 		int linux_wait4(
 		    l_pid_t pid,
 		    l_int *status,
 		    l_int options,
 		    struct rusage *rusage
 		);
 	}
 62	AUE_KILL	STD {
 		int linux_kill(
 		    l_pid_t pid,
 		    l_int signum
 		);
 	}
 63	AUE_NULL	STD {
 		int linux_newuname(
 		    struct l_new_utsname *buf
 		);
 	}
 64	AUE_NULL	STD {
 		int linux_semget(
 		    l_key_t key,
 		    l_int nsems,
 		    l_int semflg
 		);
 	}
 65	AUE_NULL	STD {
 		int linux_semop(
 		    l_int semid,
 		    struct l_sembuf *tsops,
 		    l_uint nsops
 		);
 	}
 66	AUE_NULL	STD {
 		int linux_semctl(
 		    l_int semid,
 		    l_int semnum,
 		    l_int cmd,
 		    union l_semun arg
 		);
 	}
 67	AUE_NULL	STD {
 		int linux_shmdt(
 		    char *shmaddr
 		);
 	}
 68	AUE_NULL	STD {
 		int linux_msgget(
 		    l_key_t key,
 		    l_int msgflg
 		);
 	}
 69	AUE_NULL	STD {
 		int linux_msgsnd(
 		    l_int msqid,
 		    struct l_msgbuf *msgp,
 		    l_size_t msgsz,
 		    l_int msgflg
 		);
 	}
 70	AUE_NULL	STD {
 		int linux_msgrcv(
 		    l_int msqid,
 		    struct l_msgbuf *msgp,
 		    l_size_t msgsz,
 		    l_long msgtyp,
 		    l_int msgflg
 		);
 	}
 71	AUE_NULL	STD {
 		int linux_msgctl(
 		    l_int msqid,
 		    l_int cmd,
 		    struct l_msqid_ds *buf
 		);
 	}
 72	AUE_FCNTL	STD {
 		int linux_fcntl(
 		    l_uint fd,
 		    l_uint cmd,
 		    l_ulong arg
 		);
 	}
 73	AUE_FLOCK	NOPROTO {
 		int flock(
 		    int fd,
 		    int how
 		);
 	}
 74	AUE_FSYNC	NOPROTO {
 		int fsync(
 		    int fd
 		);
 	}
 75	AUE_NULL	STD {
 		int linux_fdatasync(
 		    l_uint fd
 		);
 	}
 76	AUE_TRUNCATE	STD {
 		int linux_truncate(
 		    char *path,
 		    l_long length
 		);
 	}
 77	AUE_FTRUNCATE	STD {
 		int linux_ftruncate(
 		    l_int fd,
 		    l_ulong length
 		);
 	}
 78	AUE_GETDIRENTRIES	STD  {
 		int linux_getdents(
 		    l_uint fd,
 		    void *dent,
 		    l_uint count
 		);
 	}
 79	AUE_GETCWD	STD {
 		int linux_getcwd(
 		    char *buf,
 		    l_ulong bufsize
 		);
 	}
 80	AUE_CHDIR	STD {
 		int linux_chdir(
 		    char *path
 		);
 	}
 81	AUE_FCHDIR	NOPROTO {
 		int fchdir(
 		    int fd
 		);
 	}
 82	AUE_RENAME	STD {
 		int linux_rename(
 		    char *from,
 		    char *to
 		);
 	}
 83	AUE_MKDIR	STD {
 		int linux_mkdir(
 		    char *path,
 		    l_mode_t mode
 		);
 	}
 84	AUE_RMDIR	STD {
 		int linux_rmdir(
 		    char *path
 		);
 	}
 85	AUE_CREAT	STD {
 		int linux_creat(
 		    char *path,
 		    l_mode_t mode
 		);
 	}
 86	AUE_LINK	STD {
 		int linux_link(
 		    char *path,
 		    char *to
 		);
 	}
 87	AUE_UNLINK	STD {
 		int linux_unlink(
 		    char *path
 		);
 	}
 88	AUE_SYMLINK	STD {
 		int linux_symlink(
 		    char *path,
 		    char *to
 		);
 	}
 89	AUE_READLINK	STD {
 		int linux_readlink(
 		    char *name,
 		    char *buf,
 		    l_int count
 		);
 	}
 90	AUE_CHMOD	STD {
 		int linux_chmod(
 		    char *path,
 		    l_mode_t mode
 		);
 	}
 91	AUE_FCHMOD	NOPROTO {
 		int fchmod(
 		    int fd,
 		    int mode
 		);
 	}
 92	AUE_LCHOWN	STD {
 		int linux_chown(
 		    char *path,
 		    l_uid_t uid,
 		    l_gid_t gid
 		);
 	}
 93	AUE_FCHOWN	NOPROTO {
 		int fchown(
 		    int fd,
 		    int uid,
 		    int gid
 		);
 	}
 94	AUE_LCHOWN	STD {
 		int linux_lchown(
 		    char *path,
 		    l_uid_t uid,
 		    l_gid_t gid
 		);
 	}
 95	AUE_UMASK	NOPROTO {
 		int umask(
 		    int newmask
 		);
 	}
 96	AUE_NULL	NOPROTO {
 		int gettimeofday(
 		    struct l_timeval *tp,
 		    struct timezone *tzp
 		);
 	}
 97	AUE_GETRLIMIT	STD {
 		int linux_getrlimit(
 		    l_uint resource,
 		    struct l_rlimit *rlim
 		);
 	}
 98	AUE_GETRUSAGE	NOPROTO {
 		int getrusage(
 		    int who,
 		    struct rusage *rusage
 		);
 	}
 99	AUE_NULL	STD {
 		int linux_sysinfo(
 		    struct l_sysinfo *info
 		);
 	}
 100	AUE_NULL	STD {
 		int linux_times(
 		    struct l_times_argv *buf
 		);
 	}
 101	AUE_PTRACE	STD {
 		int linux_ptrace(
 		    l_long req,
 		    l_long pid,
 		    l_ulong addr,
 		    l_ulong data
 		);
 	}
 102	AUE_GETUID	STD {
 		int linux_getuid(void);
 	}
 103	AUE_NULL	STD {
 		int linux_syslog(
 		    l_int type,
 		    char *buf,
 		    l_int len
 		);
 	}
 104	AUE_GETGID	STD {
 		int linux_getgid(void);
 	}
 105	AUE_SETUID	NOPROTO {
 		int setuid(
 		    uid_t uid
 		);
 	}
 106	AUE_SETGID	NOPROTO {
 		int setgid(
 		    gid_t gid
 		);
 	}
 107	AUE_GETEUID	NOPROTO {
 		int geteuid(void);
 	}
 108	AUE_GETEGID	NOPROTO {
 		int getegid(void);
 	}
 109	AUE_SETPGRP	NOPROTO {
 		int setpgid(
 		    int pid,
 		    int pgid
 		);
 	}
 110	AUE_GETPPID	STD {
 		int linux_getppid(void);
 	}
 111	AUE_GETPGRP	NOPROTO {
 		int getpgrp(void);
 	}
 112	AUE_SETSID	NOPROTO {
 		int setsid(void);
 	}
 113	AUE_SETREUID	NOPROTO {
 		int setreuid(
 		    uid_t ruid,
 		    uid_t euid
 		);
 	}
 114	AUE_SETREGID	NOPROTO {
 		int setregid(
 		    gid_t rgid,
 		    gid_t egid
 		);
 	}
 115	AUE_GETGROUPS	STD {
 		int linux_getgroups(
 		    l_int gidsetsize,
 		    l_gid_t *grouplist
 		);
 	}
 116	AUE_SETGROUPS	STD {
 		int linux_setgroups(
 		    l_int gidsetsize,
 		    l_gid_t *grouplist
 		);
 	}
 117	AUE_SETRESUID	NOPROTO {
 		int setresuid(
 		    uid_t ruid,
 		    uid_t euid,
 		    uid_t suid
 		);
 	}
 118	AUE_GETRESUID	NOPROTO {
 		int getresuid(
 		    uid_t *ruid,
 		    uid_t *euid,
 		    uid_t *suid
 		);
 	}
 119	AUE_SETRESGID	NOPROTO {
 		int setresgid(
 		    gid_t rgid,
 		    gid_t egid,
 		    gid_t sgid
 		);
 	}
 120	AUE_GETRESGID	NOPROTO {
 		int getresgid(
 		    gid_t *rgid,
 		    gid_t *egid,
 		    gid_t *sgid
 		);
 	}
 121	AUE_GETPGID	NOPROTO {
 		int getpgid(
 		    int pid
 		);
 	}
 122	AUE_SETFSUID	STD {
 		int linux_setfsuid(
 		    l_uid_t uid
 		);
 	}
 123	AUE_SETFSGID	STD {
 		int linux_setfsgid(
 		    l_gid_t gid
 		);
 	}
 124	AUE_GETSID	STD {
 		int linux_getsid(
 		    l_pid_t pid
 		);
 	}
 125	AUE_CAPGET	STD {
 		int linux_capget(
 		    struct l_user_cap_header *hdrp,
 		    struct l_user_cap_data *datap
 		);
 	}
 126	AUE_CAPSET	STD {
 		int linux_capset(
 		    struct l_user_cap_header *hdrp,
 		    struct l_user_cap_data *datap
 		);
 	}
 127	AUE_NULL	STD {
 		int linux_rt_sigpending(
 		    l_sigset_t *set,
 		    l_size_t sigsetsize
 		);
 	}
 128	AUE_NULL	STD {
 		int linux_rt_sigtimedwait(
 		    l_sigset_t *mask,
 		    l_siginfo_t *ptr,
 		    struct l_timespec *timeout,
 		    l_size_t sigsetsize
 		);
 	}
 129	AUE_NULL	STD {
 		int linux_rt_sigqueueinfo(
 		    l_pid_t pid,
 		    l_int sig,
 		    l_siginfo_t *info
 		);
 	}
 130	AUE_NULL	STD {
 		int linux_rt_sigsuspend(
 		    l_sigset_t *newset,
 		    l_size_t sigsetsize
 		);
 	}
 131	AUE_NULL	STD {
 		int linux_sigaltstack(
 		    l_stack_t *uss,
 		    l_stack_t *uoss
 		);
 	}
 132	AUE_UTIME	STD {
 		int linux_utime(
 		    char *fname,
 		    struct l_utimbuf *times
 		);
 	}
 133	AUE_MKNOD	STD {
 		int linux_mknod(
 		    char *path,
 		    l_mode_t mode,
 		    l_uint dev
 		);
 	}
 134	AUE_USELIB	UNIMPL	uselib
 135	AUE_PERSONALITY	STD {
 		int linux_personality(
 		    l_uint per
 		);
 	}
 136	AUE_NULL	STD {
 		int linux_ustat(
 		    l_uint dev,
 		    struct l_ustat *ubuf
 		);
 	}
 137	AUE_STATFS	STD {
 		int linux_statfs(
 		    char *path,
 		    struct l_statfs_buf *buf
 		);
 	}
 138	AUE_FSTATFS	STD {
 		int linux_fstatfs(
 		    l_uint fd,
 		    struct l_statfs_buf *buf
 		);
 	}
 139	AUE_NULL	STD {
 		int linux_sysfs(
 		    l_int option,
 		    l_ulong arg1,
 		    l_ulong arg2
 		);
 	}
 140	AUE_GETPRIORITY	STD {
 		int linux_getpriority(
 		    l_int which,
 		    l_int who
 		);
 	}
 141	AUE_SETPRIORITY	NOPROTO {
 		int setpriority(
 		    int which,
 		    int who,
 		    int prio
 		);
 	}
 142	AUE_SCHED_SETPARAM	STD {
 		int linux_sched_setparam(
 		    l_pid_t pid,
 		    struct sched_param *param
 		);
 	}
 143	AUE_SCHED_GETPARAM	STD {
 		int linux_sched_getparam(
 		    l_pid_t pid,
 		    struct sched_param *param
 		);
 	}
 144	AUE_SCHED_SETSCHEDULER	STD  {
 		int linux_sched_setscheduler(
 		    l_pid_t pid,
 		    l_int policy,
 		    struct sched_param *param
 		);
 	}
 145	AUE_SCHED_GETSCHEDULER	STD  {
 		int linux_sched_getscheduler(
 		    l_pid_t pid
 		);
 	}
 146	AUE_SCHED_GET_PRIORITY_MAX	STD  {
 		int linux_sched_get_priority_max(
 		    l_int policy
 		);
 	}
 147	AUE_SCHED_GET_PRIORITY_MIN	STD  {
 		int linux_sched_get_priority_min(
 		    l_int policy
 		);
 	}
 148	AUE_SCHED_RR_GET_INTERVAL	STD  {
 		int linux_sched_rr_get_interval(
 		    l_pid_t pid,
 		    struct l_timespec *interval
 		);
 	}
 149	AUE_MLOCK	NOPROTO {
 		int mlock(
 		    const void *addr,
 		    size_t len
 		);
 	}
 150	AUE_MUNLOCK	NOPROTO {
 		int munlock(
 		    const void *addr,
 		    size_t len
 		);
 	}
 151	AUE_MLOCKALL	NOPROTO {
 		int mlockall(
 		    int how
 		);
 	}
 152	AUE_MUNLOCKALL	NOPROTO {
 		int munlockall(void);
 	}
 153	AUE_NULL	STD {
 		int linux_vhangup(void);
 	}
 154	AUE_NULL	STD {
 		int linux_modify_ldt(void);
 	}
 155	AUE_PIVOT_ROOT	STD {
 		int linux_pivot_root(void);
 	}
 156	AUE_SYSCTL	STD {
 		int linux_sysctl(
 		    struct l___sysctl_args *args
 		);
 	}
 157	AUE_PRCTL	STD {
 		int linux_prctl(
 		    l_int option,
 		    l_uintptr_t arg2,
 		    l_uintptr_t arg3,
 		    l_uintptr_t arg4,
 		    l_uintptr_t arg5
 		);
 	}
 158	AUE_PRCTL	STD {
 		int linux_arch_prctl(
 		    l_int code,
 		    l_ulong addr
 		);
 	}
 159	AUE_ADJTIME	STD {
 		int linux_adjtimex(void);
 	}
 160	AUE_SETRLIMIT	STD {
 		int linux_setrlimit(
 		    l_uint resource,
 		    struct l_rlimit *rlim
 		);
 	}
 161	AUE_CHROOT	NOPROTO {
 		int chroot(
 		    char *path
 		);
 	}
 162	AUE_SYNC	NOPROTO {
 		int sync(void);
 	}
 163	AUE_ACCT	NOPROTO {
 		int acct(
 		    char *path
 		);
 	}
 164	AUE_SETTIMEOFDAY	NOPROTO {
 		int settimeofday(
 		    struct l_timeval *tv,
 		    struct timezone *tzp
 		);
 	}
 165	AUE_MOUNT	STD {
 		int linux_mount(
 		    char *specialfile,
 		    char *dir,
 		    char *filesystemtype,
 		    l_ulong rwflag,
 		    void *data
 		);
 	}
 166	AUE_UMOUNT	STD {
 		int linux_umount(
 		    char *path,
 		    l_int flags
 		);
 	}
 167	AUE_SWAPON	NOPROTO {
 		int swapon(
 		    char *name
 		);
 	}
 168	AUE_SWAPOFF	STD {
 		int linux_swapoff(void);
 	}
 169	AUE_REBOOT	STD {
 		int linux_reboot(
 		    l_int magic1,
 		    l_int magic2,
 		    l_uint cmd,
 		    void *arg
 		);
 	}
 170	AUE_SYSCTL	STD {
 		int linux_sethostname(
 		    char *hostname,
 		    l_int len
 		);
 	}
 171	AUE_SYSCTL	STD {
 		int linux_setdomainname(
 		    char *name,
 		    l_int len
 		);
 	}
 172	AUE_NULL	STD {
 		int linux_iopl(
 		    l_uint level
 		);
 	}
 173	AUE_NULL	STD {
 		int linux_ioperm(void);
 	}
 174	AUE_NULL	UNIMPL	create_module
 175	AUE_NULL	STD {
 		int linux_init_module(void);
 	}
 176	AUE_NULL	STD {
 		int linux_delete_module(void);
 	}
 177	AUE_NULL	UNIMPL	get_kernel_syms
 178	AUE_NULL	UNIMPL	query_module
 179	AUE_QUOTACTL	STD {
 		int linux_quotactl(void);
 	}
 180	AUE_NULL	UNIMPL	nfsservctl
 181	AUE_GETPMSG	UNIMPL	getpmsg
 182	AUE_PUTPMSG	UNIMPL	putpmsg
 183	AUE_NULL	UNIMPL	afs_syscall
 184	AUE_NULL	UNIMPL	tuxcall
 185	AUE_NULL	UNIMPL	security
 186	AUE_NULL	STD {
 		int linux_gettid(void);
 	}
 187	AUE_NULL	STD {
 		int linux_readahead(void);
 	}
 188	AUE_NULL	STD {
 		int linux_setxattr(
 		    const char *path,
 		    const char *name,
 		    const char *value,
 		    l_size_t size,
 		    l_int flags
 		);
 	}
 189	AUE_NULL	STD {
 		int linux_lsetxattr(
 		    const char *path,
 		    const char *name,
 		    const char *value,
 		    l_size_t size,
 		    l_int flags
 		);
 	}
 190	AUE_NULL	STD {
 		int linux_fsetxattr(
 		    l_int fd,
 		    const char *name,
 		    const char *value,
 		    l_size_t size,
 		    l_int flags
 		);
 	}
 191	AUE_NULL	STD {
 		int linux_getxattr(
 		    const char *path,
 		    const char *name,
 		    char *value,
 		    l_size_t size
 		);
 	}
 192	AUE_NULL	STD {
 		int linux_lgetxattr(
 		    const char *path,
 		    const char *name,
 		    char *value,
 		    l_size_t size
 		);
 	}
 193	AUE_NULL	STD {
 		int linux_fgetxattr(
 		    l_int fd,
 		    const char *name,
 		    char *value,
 		    l_size_t size
 		);
 	}
 194	AUE_NULL	STD {
 		int linux_listxattr(
 		    const char *path,
 		    const char *list,
 		    l_size_t size
 		);
 	}
 195	AUE_NULL	STD {
 		int linux_llistxattr(
 		    const char *path,
 		    const char *list,
 		    l_size_t size
 		);
 	}
 196	AUE_NULL	STD {
 		int linux_flistxattr(
 		    l_int fd,
 		    const char *list,
 		    l_size_t size
 		);
 	}
 197	AUE_NULL	STD {
 		int linux_removexattr(
 		    const char *path,
 		    const char *name
 		);
 	}
 198	AUE_NULL	STD {
 		int linux_lremovexattr(
 		    const char *path,
 		    const char *name
 		);
 	}
 199	AUE_NULL	STD {
 		int linux_fremovexattr(
 		    l_int fd,
 		    const char *name
 		);
 	}
 200	AUE_NULL	STD {
 		int linux_tkill(
 		    l_pid_t tid,
 		    l_int sig
 		);
 	}
 201	AUE_NULL	STD {
 		int linux_time(
 		    l_time_t *tm
 		);
 	}
 202	AUE_NULL	STD {
 		int linux_sys_futex(
 		    uint32_t *uaddr,
 		    l_int op,
 		    uint32_t val,
 		    struct l_timespec *timeout,
 		    uint32_t *uaddr2,
 		    uint32_t val3
 		);
 	}
 203	AUE_NULL	STD {
 		int linux_sched_setaffinity(
 		    l_pid_t pid,
 		    l_uint len,
 		    l_ulong *user_mask_ptr
 		);
 	}
 204	AUE_NULL	STD {
 		int linux_sched_getaffinity(
 		    l_pid_t pid,
 		    l_uint len,
 		    l_ulong *user_mask_ptr
 		);
 	}
 205	AUE_NULL	UNIMPL	set_thread_area
 206	AUE_NULL	STD {
 		int linux_io_setup(void);
 	}
 207	AUE_NULL	STD {
 		int linux_io_destroy(void);
 	}
 208	AUE_NULL	STD {
 		int linux_io_getevents(void);
 	}
 209	AUE_NULL	STD {
 		int linux_io_submit(void);
 	}
 210	AUE_NULL	STD {
 		int linux_io_cancel(void);
 	}
 211	AUE_NULL	UNIMPL	get_thread_area
 212	AUE_NULL	STD {
 		int linux_lookup_dcookie(void);
 	}
 213	AUE_NULL	STD {
 		int linux_epoll_create(
 		    l_int size
 		);
 	}
 214	AUE_NULL	UNIMPL	epoll_ctl_old
 215	AUE_NULL	UNIMPL	epoll_wait_old
 216	AUE_NULL	STD {
 		int linux_remap_file_pages(void);
 	}
 217	AUE_GETDIRENTRIES	STD  {
 		int linux_getdents64(
 		    l_uint fd,
 		    void *dirent,
 		    l_uint count
 		);
 	}
 218	AUE_NULL	STD {
 		int linux_set_tid_address(
 		    l_int *tidptr
 		);
 	}
 219	AUE_NULL	STD {
 		int linux_restart_syscall(void);
 	}
 220	AUE_NULL	STD {
 		int linux_semtimedop(void);
 	}
 221	AUE_NULL	STD {
 		int linux_fadvise64(
 		    l_int fd,
 		    l_loff_t offset,
 		    l_size_t len,
 		    l_int advice
 		);
 	}
 222	AUE_NULL	STD {
 		int linux_timer_create(
 		    clockid_t clock_id,
 		    struct sigevent *evp,
 		    l_timer_t *timerid
 		);
 	}
 223	AUE_NULL	STD {
 		int linux_timer_settime(
 		    l_timer_t timerid,
 		    l_int flags,
 		    const struct itimerspec *new,
 		    struct itimerspec *old
 		);
 	}
 224	AUE_NULL	STD {
 		int linux_timer_gettime(
 		    l_timer_t timerid,
 		    struct itimerspec *setting
 		);
 	}
 225	AUE_NULL	STD {
 		int linux_timer_getoverrun(
 		    l_timer_t timerid
 		);
 	}
 226	AUE_NULL	STD {
 		int linux_timer_delete(
 		    l_timer_t timerid
 		);
 	}
 227	AUE_CLOCK_SETTIME	STD {
 		int linux_clock_settime(
 		    clockid_t which,
 		    struct l_timespec *tp
 		);
 	}
 228	AUE_NULL	STD {
 		int linux_clock_gettime(
 		    clockid_t which,
 		    struct l_timespec *tp
 		);
 	}
 229	AUE_NULL	STD {
 		int linux_clock_getres(
 		    clockid_t which,
 		    struct l_timespec *tp
 		);
 	}
 230	AUE_NULL	STD {
 		int linux_clock_nanosleep(
 		    clockid_t which,
 		    l_int flags,
 		    struct l_timespec *rqtp,
 		    struct l_timespec *rmtp
 		);
 	}
 231	AUE_EXIT	STD {
 		int linux_exit_group(
 		    l_int error_code
 		);
 	}
 232	AUE_NULL	STD {
 		int linux_epoll_wait(
 		    l_int epfd,
 		    struct epoll_event *events,
 		    l_int maxevents,
 		    l_int timeout
 		);
 	}
 233	AUE_NULL	STD {
 		int linux_epoll_ctl(
 		    l_int epfd,
 		    l_int op,
 		    l_int fd,
 		    struct epoll_event *event
 		);
 	}
 234	AUE_NULL	STD {
 		int linux_tgkill(
 		    l_pid_t tgid,
 		    l_pid_t pid,
 		    l_int sig
 		);
 	}
 235	AUE_UTIMES	STD {
 		int linux_utimes(
 		    char *fname,
 		    struct l_timeval *tptr
 		);
 	}
 236	AUE_NULL	UNIMPL	vserver
 237	AUE_NULL	STD {
 		int linux_mbind(void);
 	}
 238	AUE_NULL	STD {
 		int linux_set_mempolicy(void);
 	}
 239	AUE_NULL	STD {
 		int linux_get_mempolicy(void);
 	}
 240	AUE_NULL	STD {
 		int linux_mq_open(
 		    const char *name,
 		    l_int oflag,
 		    l_mode_t mode,
 		    struct mq_attr *attr
 		);
 	}
 241	AUE_NULL	STD {
 		int linux_mq_unlink(
 		    const char *name
 		);
 	}
 242	AUE_NULL	STD {
 		int linux_mq_timedsend(
 		    l_mqd_t mqd,
 		    const char *msg_ptr,
 		    l_size_t msg_len,
 		    l_uint msg_prio,
 		    const struct l_timespec *abs_timeout
 		);
 	}
 243	AUE_NULL	STD {
 		int linux_mq_timedreceive(
 		    l_mqd_t mqd,
 		    char *msg_ptr,
 		    l_size_t msg_len,
 		    l_uint *msg_prio,
 		    const struct l_timespec *abs_timeout
 		);
 	}
 244	AUE_NULL	STD {
 		int linux_mq_notify(
 		    l_mqd_t mqd,
 		    const struct l_timespec *abs_timeout
 		);
 	}
 245	AUE_NULL	STD {
 		int linux_mq_getsetattr(
 		    l_mqd_t mqd,
 		    const struct mq_attr *attr,
 		    struct mq_attr *oattr
 		);
 	}
 246	AUE_NULL	STD {
 		int linux_kexec_load(void);
 	}
 247	AUE_WAIT6	STD {
 		int linux_waitid(
 		    l_int idtype,
 		    l_pid_t id,
 		    l_siginfo_t *info,
 		    l_int options,
 		    struct rusage *rusage
 		);
 	}
 248	AUE_NULL	STD {
 		int linux_add_key(void);
 	}
 249	AUE_NULL	STD {
 		int linux_request_key(void);
 	}
 250	AUE_NULL	STD {
 		int linux_keyctl(void);
 	}
 251	AUE_NULL	STD {
 		int linux_ioprio_set(void);
 	}
 252	AUE_NULL	STD {
 		int linux_ioprio_get(void);
 	}
 253	AUE_NULL	STD {
 		int linux_inotify_init(void);
 	}
 254	AUE_NULL	STD {
 		int linux_inotify_add_watch(void);
 	}
 255	AUE_NULL	STD {
 		int linux_inotify_rm_watch(void);
 	}
 256	AUE_NULL	STD {
 		int linux_migrate_pages(void);
 	}
 257	AUE_OPEN_RWTC	STD {
 		int linux_openat(
 		    l_int dfd,
 		    const char *filename,
 		    l_int flags,
 		    l_mode_t mode
 		);
 	}
 258	AUE_MKDIRAT	STD {
 		int linux_mkdirat(
 		    l_int dfd,
 		    const char *pathname,
 		    l_mode_t mode
 		);
 	}
 259	AUE_MKNODAT	STD {
 		int linux_mknodat(
 		    l_int dfd,
 		    const char *filename,
 		    l_mode_t mode,
 		    l_uint dev
 		);
 	}
 260	AUE_FCHOWNAT	STD {
 		int linux_fchownat(
 		    l_int dfd,
 		    const char *filename,
 		    l_uid_t uid,
 		    l_gid_t gid,
 		    l_int flag
 		);
 	}
 261	AUE_FUTIMESAT	STD {
 		int linux_futimesat(
 		    l_int dfd,
 		    char *filename,
 		    struct l_timeval *utimes
 		);
 	}
 262	AUE_FSTATAT	STD {
 		int linux_newfstatat(
 		    l_int dfd,
 		    char *pathname,
 		    struct l_stat64 *statbuf,
 		    l_int flag
 		);
 	}
 263	AUE_UNLINKAT	STD {
 		int linux_unlinkat(
 		    l_int dfd,
 		    const char *pathname,
 		    l_int flag
 		);
 	}
 264	AUE_RENAMEAT	STD {
 		int linux_renameat(
 		    l_int olddfd,
 		    const char *oldname,
 		    l_int newdfd,
 		    const char *newname
 		);
 	}
 265	AUE_LINKAT	STD {
 		int linux_linkat(
 		    l_int olddfd,
 		    const char *oldname,
 		    l_int newdfd,
 		    const char *newname,
 		    l_int flag
 		);
 	}
 266	AUE_SYMLINKAT	STD {
 		int linux_symlinkat(
 		    const char *oldname,
 		    l_int newdfd,
 		    const char *newname
 		);
 	}
 267	AUE_READLINKAT	STD {
 		int linux_readlinkat(
 		    l_int dfd,
 		    const char *path,
 		    char *buf,
 		    l_int bufsiz
 		);
 	}
 268	AUE_FCHMODAT	STD {
 		int linux_fchmodat(
 		    l_int dfd,
 		    const char *filename,
 		    l_mode_t mode
 		);
 	}
 269	AUE_FACCESSAT	STD {
 		int linux_faccessat(
 		    l_int dfd,
 		    const char *filename,
 		    l_int amode
 		);
 	}
 270	AUE_SELECT	STD {
 		int linux_pselect6(
 		    l_int nfds,
 		    l_fd_set *readfds,
 		    l_fd_set *writefds,
 		    l_fd_set *exceptfds,
 		    struct l_timespec *tsp,
 		    l_uintptr_t *sig
 		);
 	}
 271	AUE_POLL	STD {
 		int linux_ppoll(
 		    struct pollfd *fds,
 		    l_uint nfds,
 		    struct l_timespec *tsp,
 		    l_sigset_t *sset,
 		    l_size_t ssize
 		);
 	}
 272	AUE_NULL	STD {
 		int linux_unshare(void);
 	}
 273	AUE_NULL	STD {
 		int linux_set_robust_list(
 		    struct linux_robust_list_head *head,
 		    l_size_t len
 		);
 	}
 274	AUE_NULL	STD {
 		int linux_get_robust_list(
 		    l_int pid,
 		    struct linux_robust_list_head **head,
 		    l_size_t *len
 		);
 	}
 275	AUE_NULL	STD {
 		int linux_splice(
 		    int fd_in,
 		    l_loff_t *off_in,
 		    int fd_out,
 		    l_loff_t *off_out,
 		    l_size_t len,
 		    l_uint flags
 		);
 	}
 276	AUE_NULL	STD {
 		int linux_tee(void);
 	}
 277	AUE_NULL	STD {
 		int linux_sync_file_range(
 		    l_int fd,
 		    l_loff_t offset,
 		    l_loff_t nbytes,
 		    l_uint flags
 		);
 	}
 278	AUE_NULL	STD {
 		int linux_vmsplice(void);
 	}
 279	AUE_NULL	STD {
 		int linux_move_pages(void);
 	}
 280	AUE_FUTIMESAT	STD {
 		int linux_utimensat(
 		    l_int dfd,
 		    const char *pathname,
 		    const struct l_timespec *times,
 		    l_int flags
 		);
 	}
 281	AUE_NULL	STD {
 		int linux_epoll_pwait(
 		    l_int epfd,
 		    struct epoll_event *events,
 		    l_int maxevents,
 		    l_int timeout,
 		    l_sigset_t *mask,
 		    l_size_t sigsetsize
 		);
 	}
 282	AUE_NULL	STD {
 		int linux_signalfd(void);
 	}
 283	AUE_NULL	STD {
 		int linux_timerfd_create(
 		    l_int clockid,
 		    l_int flags
 		);
 	}
 284	AUE_NULL	STD {
 		int linux_eventfd(
 		    l_uint initval
 		);
 	}
 285	AUE_NULL	STD {
 		int linux_fallocate(
 		    l_int fd,
 		    l_int mode,
 		    l_loff_t offset,
 		    l_loff_t len
 		);
 	}
 286	AUE_NULL	STD {
 		int linux_timerfd_settime(
 		    l_int fd,
 		    l_int flags,
 		    const struct l_itimerspec *new_value,
 		    struct l_itimerspec *old_value
 		);
 	}
 287	AUE_NULL	STD {
 		int linux_timerfd_gettime(
 		    l_int fd,
 		    struct l_itimerspec *old_value
 		);
 	}
 288	AUE_ACCEPT	STD {
 		int linux_accept4(
 		    l_int s,
 		    l_uintptr_t addr,
 		    l_uintptr_t namelen,
 		    l_int flags
 		);
 	}
 ; Linux 2.6.27:
 289	AUE_NULL	STD {
 		int linux_signalfd4(void);
 	}
 290	AUE_NULL	STD {
 		int linux_eventfd2(
 		    l_uint initval,
 		    l_int flags
 		);
 	}
 291	AUE_NULL	STD {
 		int linux_epoll_create1(
 		    l_int flags
 		);
 	}
 292	AUE_NULL	STD {
 		int linux_dup3(
 		    l_uint oldfd,
 		    l_uint newfd,
 		    l_int flags
 		);
 	}
 293	AUE_NULL	STD {
 		int linux_pipe2(
 		    l_int *pipefds,
 		    l_int flags
 		);
 	}
 294	AUE_NULL	STD {
 		int linux_inotify_init1(
 		    l_int flags
 		);
 	}
 ; Linux 2.6.30:
 295	AUE_NULL	STD {
 		int linux_preadv(
 		    l_ulong fd,
 		    struct iovec *vec,
 		    l_ulong vlen,
 		    l_ulong pos_l,
 		    l_ulong pos_h
 		);
 	}
 296	AUE_NULL	STD {
 		int linux_pwritev(
 		    l_ulong fd,
 		    struct iovec *vec,
 		    l_ulong vlen,
 		    l_ulong pos_l,
 		    l_ulong pos_h
 		);
 	}
 ; Linux 2.6.31:
 297	AUE_NULL	STD {
 		int linux_rt_tgsigqueueinfo(
 		    l_pid_t tgid,
 		    l_pid_t tid,
 		    l_int sig,
 		    l_siginfo_t *uinfo
 		);
 	}
 298	AUE_NULL	STD {
 		int linux_perf_event_open(void);
 	}
 ; Linux 2.6.33:
 299	AUE_NULL	STD {
 		int linux_recvmmsg(
 		    l_int s,
 		    struct l_mmsghdr *msg,
 		    l_uint vlen,
 		    l_uint flags,
 		    struct l_timespec *timeout
 		);
 	}
 ; Linux 2.6.37:
 300	AUE_NULL	STD {
 		int linux_fanotify_init(void);
 	}
 301	AUE_NULL	STD {
 		int linux_fanotify_mark(void);
 	}
 ; Linux 2.6.36:
 302	AUE_NULL	STD {
 		int linux_prlimit64(
 		    l_pid_t pid,
 		    l_uint resource,
 		    struct rlimit *new,
 		    struct rlimit *old
 		);
 	}
 ; Linux 2.6.39 (glibc 2.14):
 303	AUE_NULL	STD {
 		int linux_name_to_handle_at(
 		    l_int dirfd,
 		    const char *name,
 		    struct l_file_handle *handle,
 		    l_int *mnt_id,
 		    l_int flags
 		);
 	}
 304	AUE_NULL	STD {
 		int linux_open_by_handle_at(
 		    l_int mountdirfd,
 		    struct l_file_handle *handle,
 		    l_int flags
 		);
 	}
 305	AUE_NULL	STD {
 		int linux_clock_adjtime(void);
 	}
 306	AUE_SYNC	STD {
 		int linux_syncfs(
 		    l_int fd
 		);
 	}
 ; Linux 3.0 (glibc 2.14):
 307	AUE_NULL	STD {
 		int linux_sendmmsg(
 		    l_int s,
 		    struct l_mmsghdr *msg,
 		    l_uint vlen,
 		    l_uint flags
 		);
 	}
 308	AUE_NULL	STD {
 		int linux_setns(
 		    l_int fd,
 		    l_int nstype
 		);
 	}
 ; Linux 2.6.19 (no glibc wrapper):
 309	AUE_NULL	STD {
 		int linux_getcpu(
 		    l_uint *cpu,
 		    l_uint *node,
 		    void *cache
 		);
 	}
 ; Linux 3.2 (glibc 2.15):
 310	AUE_NULL	STD {
 		int linux_process_vm_readv(
 		    l_pid_t pid,
 		    const struct iovec *lvec,
 		    l_ulong liovcnt,
 		    const struct iovec *rvec,
 		    l_ulong riovcnt,
 		    l_ulong flags
 		);
 	}
 311	AUE_NULL	STD {
 		int linux_process_vm_writev(
 		    l_pid_t pid,
 		    const struct iovec *lvec,
 		    l_ulong liovcnt,
 		    const struct iovec *rvec,
 		    l_ulong riovcnt,
 		    l_ulong flags
 		);
 	}
 ; Linux 3.5 (no glibc wrapper):
 312	AUE_NULL	STD {
 		int linux_kcmp(
 		    l_pid_t pid1,
 		    l_pid_t pid2,
 		    l_int type,
 		    l_ulong idx1,
 		    l_ulong idx
 		);
 	}
 ; Linux 3.8 (no glibc wrapper):
 313	AUE_NULL	STD {
 		int linux_finit_module(
 		    l_int fd,
 		    const char *uargs,
 		    l_int flags
 		);
 	}
 ; Linux 3.14:
 314	AUE_NULL	STD {
 		int linux_sched_setattr(
 		    l_pid_t pid,
 		    void *attr,
 		    l_uint flags
 		);
 	}
 315	AUE_NULL	STD {
 		int linux_sched_getattr(
 		    l_pid_t pid,
 		    void *attr,
 		    l_uint size,
 		    l_uint flags
 		);
 	}
 ; Linux 3.15:
 316	AUE_NULL	STD {
 		int linux_renameat2(
 		    l_int olddfd,
 		    const char *oldname,
 		    l_int newdfd,
 		    const char *newname,
 		    l_uint flags
 		);
 	}
 ; Linux 3.17:
 317	AUE_NULL	STD {
 		int linux_seccomp(
 		    l_uint op,
 		    l_uint flags,
 		    const char *uargs
 		);
 	}
 318	AUE_NULL	STD {
 		int linux_getrandom(
 		    char *buf,
 		    l_size_t count,
 		    l_uint flags
 		);
 	}
 319	AUE_NULL	STD {
 		int linux_memfd_create(
 		    const char *uname_ptr,
 		    l_uint flags
 		);
 	}
 320	AUE_NULL	STD {
 		int linux_kexec_file_load(
 		    l_int kernel_fd,
 		    l_int initrd_fd,
 		    l_ulong cmdline_len,
 		    const char *cmdline_ptr,
 		    l_ulong flags
 		);
 	}
 ; Linux 3.18:
 321	AUE_NULL	STD {
 		int linux_bpf(
 		    l_int cmd,
 		    void *attr,
 		    l_uint size
 		);
 	}
 ; Linux 3.19:
 322	AUE_NULL	STD {
 		int linux_execveat(
 		    l_int dfd,
 		    const char *filename,
 		    const char **argv,
 		    const char **envp,
 		    l_int flags
 		);
 	}
 ; Linux 4.2:
 323	AUE_NULL	STD {
 		int linux_userfaultfd(
 		    l_int flags
 		);
 	}
 ; Linux 4.3:
 324	AUE_NULL	STD {
 		int linux_membarrier(
 		    l_int cmd,
 		    l_int flags
 		);
 	}
 ; Linux 4.4:
 325	AUE_NULL	STD {
 		int linux_mlock2(
 		    l_ulong start,
 		    l_size_t len,
 		    l_int flags
 		);
 	}
 ; Linux 4.5:
 326	AUE_NULL	STD {
 		int linux_copy_file_range(
 		    l_int fd_in,
 		    l_loff_t *off_in,
 		    l_int fd_out,
 		    l_loff_t *off_out,
 		    l_size_t len,
 		    l_uint flags
 		);
 	}
 ; Linux 4.6:
 327	AUE_NULL	STD {
 		int linux_preadv2(
 		    l_ulong fd,
 		    const struct iovec *vec,
 		    l_ulong vlen,
 		    l_ulong pos_l,
 		    l_ulong pos_h,
 		    l_int flags
 		);
 	}
 328	AUE_NULL	STD {
 		int linux_pwritev2(
 		    l_ulong fd,
 		    const struct iovec *vec,
 		    l_ulong vlen,
 		    l_ulong pos_l,
 		    l_ulong pos_h,
 		    l_int flags
 		);
 	}
 ; Linux 4.8:
 329	AUE_NULL	STD {
 		int linux_pkey_mprotect(
 		    l_ulong start,
 		    l_size_t len,
 		    l_ulong prot,
 		    l_int pkey
 		);
 	}
 330	AUE_NULL	STD {
 		int linux_pkey_alloc(
 		    l_ulong flags,
 		    l_ulong init_val
 		);
 	}
 331	AUE_NULL	STD {
 		int linux_pkey_free(
 		    l_int pkey
 		);
 	}
 ; Linux 4.11:
 332	AUE_NULL	STD {
 		int linux_statx(
 		    l_int dirfd,
 		    const char *pathname,
 		    l_uint flags,
 		    l_uint mask,
 		    void *statxbuf
 		);
 	}
 ; Linux 4.18:
 333	AUE_NULL	STD {
 		int linux_io_pgetevents(void);
 	}
 334	AUE_NULL	STD {
 		int linux_rseq(void);
 	}
 ; Linux 5.0:
 335-423	AUE_NULL	UNIMPL	nosys
 424	AUE_NULL	STD {
 		int linux_pidfd_send_signal(
 		    l_int pidfd,
 		    l_int sig,
 		    l_siginfo_t *info,
 		    l_uint flags
 		);
 	}
 425	AUE_NULL	STD {
 		int linux_io_uring_setup(void);
 	}
 426	AUE_NULL	STD {
 		int linux_io_uring_enter(void);
 	}
 427	AUE_NULL	STD {
 		int linux_io_uring_register(void);
 	}
 428    AUE_NULL		STD {
 		int linux_open_tree(void);
 	}
 429    AUE_NULL		STD {
 		int linux_move_mount(void);
 	}
 430    AUE_NULL		STD {
 		int linux_fsopen(void);
 	}
 431    AUE_NULL		STD {
 		int linux_fsconfig(void);
 	}
 432    AUE_NULL		STD {
 		int linux_fsmount(void);
 	}
 433    AUE_NULL		STD {
 		int linux_fspick(void);
 	}
 434    AUE_NULL		STD {
 		int linux_pidfd_open(void);
 	}
 435    AUE_NULL		STD {
 		int linux_clone3(void);
 	}
 436    AUE_NULL		STD {
 		int linux_close_range(void);
 	}
 437    AUE_NULL		STD {
 		int linux_openat2(void);
 	}
 438    AUE_NULL		STD {
 		int linux_pidfd_getfd(void);
 	}
 439    AUE_NULL		STD {
 		int linux_faccessat2(void);
 	}
 440    AUE_NULL		STD {
 		int linux_process_madvise(void);
 	}
 441    AUE_NULL		STD {
 		int linux_epoll_pwait2(void);
 	}
 442    AUE_NULL		STD {
 		int linux_mount_setattr(void);
 	}
 ; please, keep this line at the end.
 443    AUE_NULL        UNIMPL  nosys
 ; vim: syntax=off
diff --git a/sys/amd64/linux32/syscalls.master b/sys/amd64/linux32/syscalls.master
index 0ca919182998..be6c150eebfa 100644
--- a/sys/amd64/linux32/syscalls.master
+++ b/sys/amd64/linux32/syscalls.master
@@ -1,2512 +1,2512 @@
  $FreeBSD$
 
 ;	@(#)syscalls.master	8.1 (Berkeley) 7/19/93
 ; System call name/number master file (or rather, slave, from LINUX).
 ; Processed to create linux32_sysent.c, linux32_proto.h and linux32_syscall.h.
 
 ; Columns: number audit type nargs name alt{name,tag,rtyp}/comments
 ;	number	system call number, must be in order
 ;	audit	the audit event associated with the system call
 ;		A value of AUE_NULL means no auditing, but it also means that
 ;		there is no audit event for the call at this time. For the
 ;		case where the event exists, but we don't want auditing, the
 ;		event should be #defined to AUE_NULL in audit_kevents.h.
 ;	type	one of STD, NOPROTO, UNIMPL
 ;	name	pseudo-prototype of syscall routine
 ;		If one of the following alts is different, then all appear:
 ;	altname	name of system call if different
 ;	alttag	name of args struct tag if different from [o]`name'"_args"
 ;	altrtyp	return type if not int (bogus - syscalls always return int)
 ;		for UNIMPL, name continues with comments
 
 ; types:
 ;	STD	always included
 ;	UNIMPL	not implemented, placeholder only
 ;	NOPROTO	same as STD except do not create structure or
 ;		function prototype in sys/sysproto.h.  Does add a
 ;		definition to syscall.h besides adding a sysent.
 
 #include <sys/param.h>
 #include <sys/sysent.h>
 #include <sys/sysproto.h>
 #include <compat/linux/linux_sysproto.h>
 #include <amd64/linux32/linux.h>
 #include <amd64/linux32/linux32_proto.h>
 
 ; Isn't pretty, but there seems to be no other way to trap nosys
 #define	nosys	linux_nosys
 
 ; #ifdef's, etc. may be included, and are copied to the output files.
 
 0	AUE_NULL	UNIMPL	setup
 1	AUE_EXIT	STD {
 		void linux_exit(
 		    int rval
 		);
 	}
 2	AUE_FORK	STD {
 		int linux_fork(void);
 	}
 3	AUE_NULL	NOPROTO {
 		int read(
 		    int fd,
 		    char *buf,
 		    u_int nbyte
 		);
 	}
 4	AUE_NULL	NOPROTO {
 		int write(
 		    int fd,
 		    char *buf,
 		    u_int nbyte
 		);
 	}
 5	AUE_OPEN_RWTC	STD {
 		int linux_open(
 		    char *path,
 		    l_int flags,
 		    l_int mode
 		);
 	}
 6	AUE_CLOSE	NOPROTO {
 		int close(
 		    int fd
 		);
 	}
 7	AUE_WAIT4	STD {
 		int linux_waitpid(
 		    l_pid_t pid,
 		    l_int *status,
 		    l_int options
 		);
 	}
 8	AUE_CREAT	STD {
 		int linux_creat(
 		    char *path,
 		    l_int mode
 		);
 	}
 9	AUE_LINK	STD {
 		int linux_link(
 		    char *path,
 		    char *to
 		);
 	}
 10	AUE_UNLINK	STD {
 		int linux_unlink(
 		    char *path
 		);
 	}
 11	AUE_EXECVE	STD {
 		int linux_execve(
 		    char *path,
 		    uint32_t *argp,
 		    uint32_t *envp
 		);
 	}
 12	AUE_CHDIR	STD {
 		int linux_chdir(
 		    char *path
 		);
 	}
 13	AUE_NULL	STD {
 		int linux_time(
 		    l_time_t *tm
 		);
 	}
 14	AUE_MKNOD	STD {
 		int linux_mknod(
 		    char *path,
 		    l_int mode,
 		    l_dev_t dev
 		);
 	}
 15	AUE_CHMOD	STD {
 		int linux_chmod(
 		    char *path,
 		    l_mode_t mode
 		);
 	}
 16	AUE_LCHOWN	STD {
 		int linux_lchown16(
 		    char *path,
 		    l_uid16_t uid,
 		    l_gid16_t gid
 		);
 	}
 17	AUE_NULL	UNIMPL	break
 18	AUE_STAT	STD {
 		int linux_stat(
 		    char *path,
 		    struct linux_stat *up
 		);
 	}
 19	AUE_LSEEK	STD {
 		int linux_lseek(
 		    l_uint fdes,
 		    l_off_t off,
 		    l_int whence
 		);
 	}
 20	AUE_GETPID	STD {
 		int linux_getpid(void);
 	}
 21	AUE_MOUNT	STD {
 		int linux_mount(
 		    char *specialfile,
 		    char *dir,
 		    char *filesystemtype,
 		    l_ulong rwflag,
 		    void *data
 		);
 	}
 22	AUE_UMOUNT	STD {
 		int linux_oldumount(
 		    char *path
 		);
 	}
 23	AUE_SETUID	STD {
 		int linux_setuid16(
 		    l_uid16_t uid
 		);
 	}
 24	AUE_GETUID	STD {
 		int linux_getuid16(void);
 	}
 25	AUE_SETTIMEOFDAY	STD {
 		int linux_stime(void);
 	}
 26	AUE_PTRACE	STD {
 		int linux_ptrace(
 		    l_long req,
 		    l_long pid,
 		    l_long addr,
 		    l_long data
 		);
 	}
 27	AUE_NULL	STD {
 		int linux_alarm(
 		    l_uint secs
 		);
 	}
 28	AUE_FSTAT	UNIMPL	fstat
 29	AUE_NULL	STD {
 		int linux_pause(void);
 	}
 30	AUE_UTIME	STD {
 		int linux_utime(
 		    char *fname,
 		    struct l_utimbuf *times
 		);
 	}
 31	AUE_NULL	UNIMPL	stty
 32	AUE_NULL	UNIMPL	gtty
 33	AUE_ACCESS	STD {
 		int linux_access(
 		    char *path,
 		    l_int amode
 		);
 	}
 34	AUE_NICE	STD {
 		int linux_nice(
 		    l_int inc
 		);
 	}
 35	AUE_NULL	UNIMPL	ftime
 36	AUE_SYNC	NOPROTO {
 		int sync(void);
 	}
 37	AUE_KILL	STD {
 		int linux_kill(
 		    l_int pid,
 		    l_int signum
 		);
 	}
 38	AUE_RENAME	STD {
 		int linux_rename(
 		    char *from,
 		    char *to
 		);
 	}
 39	AUE_MKDIR	STD {
 		int linux_mkdir(
 		    char *path,
 		    l_int mode
 		);
 	}
 40	AUE_RMDIR	STD {
 		int linux_rmdir(
 		    char *path
 		);
 	}
 41	AUE_DUP		NOPROTO {
 		int dup(
 		    u_int fd
 		);
 	}
 42	AUE_PIPE	STD {
 		int linux_pipe(
 		    l_int *pipefds
 		);
 	}
 43	AUE_NULL	STD {
 		int linux_times(
 		    struct l_times_argv *buf
 		);
 	}
 44	AUE_NULL	UNIMPL	prof
 45	AUE_NULL	STD {
 		int linux_brk(
 		    l_ulong dsend
 		);
 	}
 46	AUE_SETGID	STD {
 		int linux_setgid16(
 		    l_gid16_t gid
 		);
 	}
 47	AUE_GETGID	STD {
 		int linux_getgid16(void);
 	}
 48	AUE_NULL	STD {
 		int linux_signal(
 		    l_int sig,
 		    l_handler_t handler
 		);
 	}
 49	AUE_GETEUID	STD {
 		int linux_geteuid16(void);
 	}
 50	AUE_GETEGID	STD {
 		int linux_getegid16(void);
 	}
 51	AUE_ACCT	NOPROTO {
 		int acct(
 		    char *path
 		);
 	}
 52	AUE_UMOUNT	STD {
 		int linux_umount(
 		    char *path,
 		    l_int flags
 		);
 	}
 53	AUE_NULL	UNIMPL	lock
 54	AUE_IOCTL	STD {
 		int linux_ioctl(
 		    l_uint fd,
 		    l_uint cmd,
 		    uintptr_t arg
 		);
 	}
 55	AUE_FCNTL	STD {
 		int linux_fcntl(
 		    l_uint fd,
 		    l_uint cmd,
 		    uintptr_t arg
 		);
 	}
 56	AUE_NULL	UNIMPL	mpx
 57	AUE_SETPGRP	NOPROTO {
 		int setpgid(
 		    int pid,
 		    int pgid
 		);
 	}
 58	AUE_NULL	UNIMPL	ulimit
 59	AUE_NULL	STD {
 		int linux_olduname(void);
 	}
 60	AUE_UMASK	NOPROTO {
 		int umask(
 		    int newmask
 		);
 	}
 61	AUE_CHROOT	NOPROTO {
 		int chroot(
 		    char *path
 		);
 	}
 62	AUE_NULL	STD {
 		int linux_ustat(
 		    l_dev_t dev,
 		    struct l_ustat *ubuf
 		);
 	}
 63	AUE_DUP2	NOPROTO {
 		int dup2(
 		    u_int from,
 		    u_int to
 		);
 	}
 64	AUE_GETPPID	STD {
 		int linux_getppid(void);
 	}
 65	AUE_GETPGRP	NOPROTO {
 		int getpgrp(void);
 	}
 66	AUE_SETSID	NOPROTO {
 		int setsid(void);
 	}
 67	AUE_NULL	STD {
 		int linux_sigaction(
 		    l_int sig,
 		    l_osigaction_t *nsa,
 		    l_osigaction_t *osa
 		);
 	}
 68	AUE_NULL	STD {
 		int linux_sgetmask(void);
 	}
 69	AUE_NULL	STD {
 		int linux_ssetmask(
 		    l_osigset_t mask
 		);
 	}
 70	AUE_SETREUID	STD {
 		int linux_setreuid16(
 		    l_uid16_t ruid,
 		    l_uid16_t euid
 		);
 	}
 71	AUE_SETREGID	STD {
 		int linux_setregid16(
 		    l_gid16_t rgid,
 		    l_gid16_t egid
 		);
 	}
 72	AUE_NULL	STD {
 		int linux_sigsuspend(
 		    l_int hist0,
 		    l_int hist1,
 		    l_osigset_t mask
 		);
 	}
 73	AUE_NULL	STD {
 		int linux_sigpending(
 		    l_osigset_t *mask
 		);
 	}
 74	AUE_SYSCTL	STD {
 		int linux_sethostname(
 		    char *hostname,
 		    u_int len
 		);
 	}
 75	AUE_SETRLIMIT	STD {
 		int linux_setrlimit(
 		    l_uint resource,
 		    struct l_rlimit *rlim
 		);
 	}
 76	AUE_GETRLIMIT	STD {
 		int linux_old_getrlimit(
 		    l_uint resource,
 		    struct l_rlimit *rlim
 		);
 	}
 77	AUE_GETRUSAGE	STD {
 		int linux_getrusage(
 		    int who,
 		    struct l_rusage *rusage
 		);
 	}
 78	AUE_NULL	STD {
 		int linux_gettimeofday(
 		    struct l_timeval *tp,
 		    struct timezone *tzp
 		);
 	}
 79	AUE_SETTIMEOFDAY STD {
 		int linux_settimeofday(
 		    struct l_timeval *tp,
 		    struct timezone *tzp
 		);
 	}
 80	AUE_GETGROUPS	STD {
 		int linux_getgroups16(
 		    l_uint gidsetsize,
 		    l_gid16_t *gidset
 		);
 	}
 81	AUE_SETGROUPS	STD {
 		int linux_setgroups16(
 		    l_uint gidsetsize,
 		    l_gid16_t *gidset
 		);
 	}
 82	AUE_SELECT	STD {
 		int linux_old_select(
 		    struct l_old_select_argv *ptr
 		);
 	}
 83	AUE_SYMLINK	STD {
 		int linux_symlink(
 		    char *path,
 		    char *to
 		);
 	}
 ; 84: oldlstat
 84	AUE_LSTAT	STD {
 		int linux_lstat(
 		    char *path,
 		    struct linux_lstat *up
 		);
 	}
 85	AUE_READLINK	STD {
 		int linux_readlink(
 		    char *name,
 		    char *buf,
 		    l_int count
 		);
 	}
 86	AUE_USELIB	UNIMPL	linux_uselib
 87	AUE_SWAPON	NOPROTO {
 		int swapon(
 		    char *name
 		);
 	}
 88	AUE_REBOOT	STD {
 		int linux_reboot(
 		    l_int magic1,
 		    l_int magic2,
 		    l_uint cmd,
 		    void *arg
 		);
 	}
 ; 89: old_readdir
 89	AUE_GETDIRENTRIES	STD  {
 		int linux_readdir(
 		    l_uint fd,
 		    struct l_dirent *dent,
 		    l_uint count
 		);
 	}
 ; 90: old_mmap
 90	AUE_MMAP	STD {
 		int linux_mmap(
 		    struct l_mmap_argv *ptr
 		);
 	}
 91	AUE_MUNMAP	NOPROTO {
 		int munmap(
 		    caddr_t addr,
 		    int len
 		);
 	}
 92	AUE_TRUNCATE	STD {
 		int linux_truncate(
 		    char *path,
 		    l_ulong length
 		);
 	}
 93	AUE_FTRUNCATE	STD {
 		int linux_ftruncate(
 		    int fd,
 		    long length
 		);
 	}
 94	AUE_FCHMOD	NOPROTO {
 		int fchmod(
 		    int fd,
 		    int mode
 		);
 	}
 95	AUE_FCHOWN	NOPROTO {
 		int fchown(
 		    int fd,
 		    int uid,
 		    int gid
 		);
 	}
 96	AUE_GETPRIORITY	STD {
 		int linux_getpriority(
 		    int which,
 		    int who
 		);
 	}
 97	AUE_SETPRIORITY	NOPROTO {
 		int setpriority(
 		    int which,
 		    int who,
 		    int prio
 		);
 	}
 98	AUE_PROFILE	UNIMPL	profil
 99	AUE_STATFS	STD {
 		int linux_statfs(
 		    char *path,
 		    struct l_statfs_buf *buf
 		);
 	}
 100	AUE_FSTATFS	STD {
 		int linux_fstatfs(
 		    l_uint fd,
 		    struct l_statfs_buf *buf
 		);
 	}
 101	AUE_NULL	UNIMPL	ioperm
 102	AUE_NULL	STD {
 		int linux_socketcall(
 		    l_int what,
 		    l_ulong args
 		);
 	}
 103	AUE_NULL	STD {
 		int linux_syslog(
 		    l_int type,
 		    char *buf,
 		    l_int len
 		);
 	}
 104	AUE_SETITIMER	STD {
 		int linux_setitimer(
 		    l_int which,
 		    struct l_itimerval *itv,
 		    struct l_itimerval *oitv
 		);
 	}
 105	AUE_GETITIMER	STD {
 		int linux_getitimer(
 		    l_int which,
 		    struct l_itimerval *itv
 		);
 	}
 106	AUE_STAT	STD {
 		int linux_newstat(
 		    char *path,
 		    struct l_newstat *buf
 		);
 	}
 107	AUE_LSTAT	STD {
 		int linux_newlstat(
 		    char *path,
 		    struct l_newstat *buf
 		);
 	}
 108	AUE_FSTAT	STD {
 		int linux_newfstat(
 		    l_uint fd,
 		    struct l_newstat *buf
 		);
 	}
 ; 109: olduname
 109	AUE_NULL	STD {
 		int linux_uname(void);
 	}
 110	AUE_NULL	STD {
 		int linux_iopl(
 		    l_int level
 		);
 	}
 111	AUE_NULL	STD {
 		int linux_vhangup(void);
 	}
 112	AUE_NULL	UNIMPL	idle
 113	AUE_NULL	UNIMPL	vm86old
 114	AUE_WAIT4	STD {
 		int linux_wait4(
 		    l_pid_t pid,
 		    l_int *status,
 		    l_int options,
 		    struct l_rusage *rusage
 		);
 	}
 115	AUE_SWAPOFF	STD {
 		int linux_swapoff(void);
 	}
 116	AUE_NULL	STD {
 		int linux_sysinfo(
 		    struct l_sysinfo *info
 		);
 	}
 117	AUE_NULL	STD {
 		int linux_ipc(
 		    l_uint what,
 		    l_int arg1,
 		    l_int arg2,
 		    l_uint arg3,
 		    l_uintptr_t ptr,
 		    l_uint arg5
 		);
 	}
 118	AUE_FSYNC	NOPROTO {
 		int fsync(
 		    int fd
 		);
 	}
 119	AUE_SIGRETURN	STD {
 		int linux_sigreturn(
 		    struct l_sigframe *sfp
 		);
 	}
 120	AUE_RFORK	STD {
 		int linux_clone(
 		    l_int flags,
 		    void *stack,
 		    void *parent_tidptr,
 		    void *tls,
 		    void *child_tidptr
 		);
 	}
 121	AUE_SYSCTL	STD {
 		int linux_setdomainname(
 		    char *name,
 		    int len
 		);
 	}
 122	AUE_NULL	STD {
 		int linux_newuname(
 		    struct l_new_utsname *buf
 		);
 	}
 123	AUE_NULL	UNIMPL	modify_ldt
 124	AUE_ADJTIME	STD {
 		int linux_adjtimex(void);
 	}
 125	AUE_MPROTECT	STD {
 		int linux_mprotect(
 		    caddr_t addr,
 		    int len,
 		    int prot
 		);
 	}
 126	AUE_SIGPROCMASK	STD {
 		int linux_sigprocmask(
 		    l_int how,
 		    l_osigset_t *mask,
 		    l_osigset_t *omask
 		);
 	}
 127	AUE_NULL	UNIMPL	create_module
 128	AUE_NULL	STD {
 		int linux_init_module(void);
 	}
 129	AUE_NULL	STD {
 		int linux_delete_module(void);
 	}
 130	AUE_NULL	UNIMPL	get_kernel_syms
 131	AUE_QUOTACTL	STD {
 		int linux_quotactl(void);
 	}
 132	AUE_GETPGID	NOPROTO {
 		int getpgid(
 		    int pid
 		);
 	}
 133	AUE_FCHDIR	NOPROTO {
 		int fchdir(
 		    int fd
 		);
 	}
 134	AUE_BDFLUSH	STD {
 		int linux_bdflush(void);
 	}
 135	AUE_NULL	STD {
 		int linux_sysfs(
 		    l_int option,
 		    l_ulong arg1,
 		    l_ulong arg2
 		);
 	}
 136	AUE_PERSONALITY	STD {
 		int linux_personality(
 		    l_uint per
 		);
 	}
 137	AUE_NULL	UNIMPL	afs_syscall
 138	AUE_SETFSUID	STD {
 		int linux_setfsuid16(
 		    l_uid16_t uid
 		);
 	}
 139	AUE_SETFSGID	STD {
 		int linux_setfsgid16(
 		    l_gid16_t gid
 		);
 	}
 140	AUE_LSEEK	STD {
 		int linux_llseek(
 		    l_int fd,
 		    l_ulong ohigh,
 		    l_ulong olow,
 		    l_loff_t *res,
 		    l_uint whence
 		);
 	}
 141	AUE_GETDIRENTRIES	STD  {
 		int linux_getdents(
 		    l_uint fd,
 		    void *dent,
 		    l_uint count
 		);
 	}
 ; 142: newselect
 142	AUE_SELECT	STD {
 		int linux_select(
 		    l_int nfds,
 		    l_fd_set *readfds,
 		    l_fd_set *writefds,
 		    l_fd_set *exceptfds,
 		    struct l_timeval *timeout
 		);
 	}
 143	AUE_FLOCK	NOPROTO {
 		int flock(
 		    int fd,
 		    int how
 		);
 	}
 144	AUE_MSYNC	STD {
 		int linux_msync(
 		    l_ulong addr,
 		    l_size_t len,
 		    l_int fl
 		);
 	}
 145	AUE_READV	STD  {
 		int linux_readv(
 		    l_ulong fd,
 		    struct l_iovec32 *iovp,
 		    l_ulong iovcnt
 		);
 	}
 146	AUE_WRITEV	STD  {
 		int linux_writev(
 		    l_ulong fd,
 		    struct l_iovec32 *iovp,
 		    l_ulong iovcnt
 		);
 	}
 147	AUE_GETSID	STD {
 		int linux_getsid(
 		    l_pid_t pid
 		);
 	}
 148	AUE_NULL	STD {
 		int linux_fdatasync(
 		    l_uint fd
 		);
 	}
 149	AUE_SYSCTL	STD {
 		int linux_sysctl(
 		    struct l___sysctl_args *args
 		);
 	}
 150	AUE_MLOCK	NOPROTO {
 		int mlock(
 		    const void *addr,
 		    size_t len
 		);
 	}
 151	AUE_MUNLOCK	NOPROTO {
 		int munlock(
 		    const void *addr,
 		    size_t len
 		);
 	}
 152	AUE_MLOCKALL	NOPROTO {
 		int mlockall(
 		    int how
 		);
 	}
 153	AUE_MUNLOCKALL	NOPROTO {
 		int munlockall(void);
 	}
 154	AUE_SCHED_SETPARAM	STD {
 		int linux_sched_setparam(
 		    l_pid_t pid,
 		    struct sched_param *param
 		);
 	}
 155	AUE_SCHED_GETPARAM	STD {
 		int linux_sched_getparam(
 		    l_pid_t pid,
 		    struct sched_param *param
 		);
 	}
 156	AUE_SCHED_SETSCHEDULER	STD  {
 		int linux_sched_setscheduler(
 		    l_pid_t pid,
 		    l_int policy,
 		    struct sched_param *param
 		);
 	}
 157	AUE_SCHED_GETSCHEDULER	STD  {
 		int linux_sched_getscheduler(
 		    l_pid_t pid
 		);
 	}
 158	AUE_NULL	NOPROTO {
 		int sched_yield(void);
 	}
 159	AUE_SCHED_GET_PRIORITY_MAX	STD  {
 		int linux_sched_get_priority_max(
 		    l_int policy
 		);
 	}
 160	AUE_SCHED_GET_PRIORITY_MIN	STD  {
 		int linux_sched_get_priority_min(
 		    l_int policy
 		);
 	}
 161	AUE_SCHED_RR_GET_INTERVAL	STD  {
 		int linux_sched_rr_get_interval(
 		    l_pid_t pid,
 		    struct l_timespec *interval
 		);
 	}
 162	AUE_NULL	STD {
 		int linux_nanosleep(
 		    const struct l_timespec *rqtp,
 		    struct l_timespec *rmtp
 		);
 	}
 163	AUE_NULL	STD {
 		int linux_mremap(
 		    l_ulong addr,
 		    l_ulong old_len,
 		    l_ulong new_len,
 		    l_ulong flags,
 		    l_ulong new_addr
 		);
 	}
 164	AUE_SETRESUID	STD {
 		int linux_setresuid16(
 		    l_uid16_t ruid,
 		    l_uid16_t euid,
 		    l_uid16_t suid
 		);
 	}
 165	AUE_GETRESUID	STD {
 		int linux_getresuid16(
 		    l_uid16_t *ruid,
 		    l_uid16_t *euid,
 		    l_uid16_t *suid
 		);
 	}
 166	AUE_NULL	UNIMPL	vm86
 167	AUE_NULL	UNIMPL	query_module
-168	AUE_POLL	NOPROTO {
-		int poll(
+168	AUE_POLL	STD {
+		int linux_poll(
 		    struct pollfd *fds,
 		    unsigned int nfds,
 		    int timeout
 		);
 	}
 169	AUE_NULL	UNIMPL	nfsservctl
 170	AUE_SETRESGID	STD {
 		int linux_setresgid16(
 		    l_gid16_t rgid,
 		    l_gid16_t egid,
 		    l_gid16_t sgid
 		);
 	}
 171	AUE_GETRESGID	STD {
 		int linux_getresgid16(
 		    l_gid16_t *rgid,
 		    l_gid16_t *egid,
 		    l_gid16_t *sgid
 		);
 	}
 172	AUE_PRCTL	STD {
 		int linux_prctl(
 		    l_int option,
 		    l_int arg2,
 		    l_int arg3,
 		    l_int arg4,
 		    l_int arg5
 		);
 	}
 173	AUE_NULL	STD {
 		int linux_rt_sigreturn(
 		    struct l_ucontext *ucp
 		);
 	}
 174	AUE_NULL	STD {
 		int linux_rt_sigaction(
 		    l_int sig,
 		    l_sigaction_t *act,
 		    l_sigaction_t *oact,
 		    l_size_t sigsetsize
 		);
 	}
 175	AUE_NULL	STD {
 		int linux_rt_sigprocmask(
 		    l_int how,
 		    l_sigset_t *mask,
 		    l_sigset_t *omask,
 		    l_size_t sigsetsize
 		);
 	}
 176	AUE_NULL	STD {
 		int linux_rt_sigpending(
 		    l_sigset_t *set,
 		    l_size_t sigsetsize
 		);
 	}
 177	AUE_NULL	STD {
 		int linux_rt_sigtimedwait(
 		    l_sigset_t *mask,
 		    l_siginfo_t *ptr,
 		    struct l_timespec *timeout,
 		    l_size_t sigsetsize
 		);
 	}
 178	AUE_NULL	STD {
 		int linux_rt_sigqueueinfo(
 		    l_pid_t pid,
 		    l_int sig,
 		    l_siginfo_t *info
 		);
 	}
 179	AUE_NULL	STD {
 		int linux_rt_sigsuspend(
 		    l_sigset_t *newset,
 		    l_size_t sigsetsize
 		);
 	}
 180	AUE_PREAD	STD {
 		int linux_pread(
 		    l_uint fd,
 		    char *buf,
 		    l_size_t nbyte,
 		    uint32_t offset1,
 		    uint32_t offset2
 		);
 	}
 181	AUE_PWRITE	STD {
 		int linux_pwrite(
 		    l_uint fd,
 		    char *buf,
 		    l_size_t nbyte,
 		    uint32_t offset1,
 		    uint32_t offset2
 		);
 	}
 182	AUE_CHOWN	STD {
 		int linux_chown16(
 		    char *path,
 		    l_uid16_t uid,
 		    l_gid16_t gid
 		);
 	}
 183	AUE_GETCWD	STD {
 		int linux_getcwd(
 		    char *buf,
 		    l_ulong bufsize
 		);
 	}
 184	AUE_CAPGET	STD {
 		int linux_capget(
 		    struct l_user_cap_header *hdrp,
 		    struct l_user_cap_data *datap
 		);
 	}
 185	AUE_CAPSET	STD {
 		int linux_capset(
 		    struct l_user_cap_header *hdrp,
 		    struct l_user_cap_data *datap
 		);
 	}
 186	AUE_NULL	STD {
 		int linux_sigaltstack(
 		    l_stack_t *uss,
 		    l_stack_t *uoss
 		);
 	}
 187	AUE_SENDFILE	STD {
 		int linux_sendfile(
 		    l_int out,
 		    l_int in,
 		    l_long *offset,
 		    l_size_t count
 		);
 	}
 188	AUE_GETPMSG	UNIMPL	getpmsg
 189	AUE_PUTPMSG	UNIMPL	putpmsg
 190	AUE_VFORK	STD {
 		int linux_vfork(void);
 	}
 ; 191: ugetrlimit
 191	AUE_GETRLIMIT	STD {
 		int linux_getrlimit(
 		    l_uint resource,
 		    struct l_rlimit *rlim
 		);
 	}
 192	AUE_MMAP	STD {
 		int linux_mmap2(
 		    l_ulong addr,
 		    l_ulong len,
 		    l_ulong prot,
 		    l_ulong flags,
 		    l_ulong fd,
 		    l_ulong pgoff
 		);
 	}
 193	AUE_TRUNCATE	STD {
 		int linux_truncate64(
 		    char *path,
 		    uint32_t length1,
 		    uint32_t length2
 		);
 	}
 194	AUE_FTRUNCATE	STD {
 		int linux_ftruncate64(
 		    l_uint fd,
 		    uint32_t length1,
 		    uint32_t length2
 		);
 	}
 195	AUE_STAT	STD {
 		int linux_stat64(
 		    const char *filename,
 		    struct l_stat64 *statbuf
 		);
 	}
 196	AUE_LSTAT	STD {
 		int linux_lstat64(
 		    const char *filename,
 		    struct l_stat64 *statbuf
 		);
 	}
 197	AUE_FSTAT	STD {
 		int linux_fstat64(
 		    l_int fd,
 		    struct l_stat64 *statbuf
 		);
 	}
 198	AUE_LCHOWN	STD {
 		int linux_lchown(
 		    char *path,
 		    l_uid_t uid,
 		    l_gid_t gid
 		);
 	}
 199	AUE_GETUID	STD {
 		int linux_getuid(void);
 	}
 200	AUE_GETGID	STD {
 		int linux_getgid(void);
 	}
 201	AUE_GETEUID	NOPROTO {
 		int geteuid(void);
 	}
 202	AUE_GETEGID	NOPROTO {
 		int getegid(void);
 	}
 203	AUE_SETREUID	NOPROTO {
 		int setreuid(
 		    uid_t ruid,
 		    uid_t euid
 		);
 	}
 204	AUE_SETREGID	NOPROTO {
 		int setregid(
 		    gid_t rgid,
 		    gid_t egid
 		);
 	}
 205	AUE_GETGROUPS	STD {
 		int linux_getgroups(
 		    l_int gidsetsize,
 		    l_gid_t *grouplist
 		);
 	}
 206	AUE_SETGROUPS	STD {
 		int linux_setgroups(
 		    l_int gidsetsize,
 		    l_gid_t *grouplist
 		);
 	}
 207	AUE_FCHOWN	NODEF	fchown fchown fchown_args int
 208	AUE_SETRESUID	NOPROTO {
 		int setresuid(
 		    uid_t ruid,
 		    uid_t euid,
 		    uid_t suid
 		);
 	}
 209	AUE_GETRESUID	NOPROTO {
 		int getresuid(
 		    uid_t *ruid,
 		    uid_t *euid,
 		    uid_t *suid
 		);
 	}
 210	AUE_SETRESGID	NOPROTO {
 		int setresgid(
 		    gid_t rgid,
 		    gid_t egid,
 		    gid_t sgid
 		);
 	}
 211	AUE_GETRESGID	NOPROTO {
 		int getresgid(
 		    gid_t *rgid,
 		    gid_t *egid,
 		    gid_t *sgid
 		);
 	}
 212	AUE_CHOWN	STD {
 		int linux_chown(
 		    char *path,
 		    l_uid_t uid,
 		    l_gid_t gid
 		);
 	}
 213	AUE_SETUID	NOPROTO {
 		int setuid(
 		    uid_t uid
 		);
 	}
 214	AUE_SETGID	NOPROTO {
 		int setgid(
 		    gid_t gid
 		);
 	}
 215	AUE_SETFSUID	STD {
 		int linux_setfsuid(
 		    l_uid_t uid
 		);
 	}
 216	AUE_SETFSGID	STD {
 		int linux_setfsgid(
 		    l_gid_t gid
 		);
 	}
 217	AUE_PIVOT_ROOT	STD {
 		int linux_pivot_root(
 		    char *new_root,
 		    char *put_old
 		);
 	}
 218	AUE_MINCORE	STD {
 		int linux_mincore(
 		    l_ulong start,
 		    l_size_t len,
 		    u_char *vec
 		);
 	}
 219	AUE_MADVISE	STD {
 		int linux_madvise(
 		    void *addr,
 		    size_t len,
 		    int behav
 		);
 	}
 220	AUE_GETDIRENTRIES	STD  {
 		int linux_getdents64(
 		    l_uint fd,
 		    void *dirent,
 		    l_uint count
 		);
 	}
 221	AUE_FCNTL	STD {
 		int linux_fcntl64(
 		    l_uint fd,
 		    l_uint cmd,
 		    uintptr_t arg
 		);
 	}
 222	AUE_NULL	UNIMPL
 223	AUE_NULL	UNIMPL
 224	AUE_NULL	STD {
 		long linux_gettid(void);
 	}
 225	AUE_NULL	UNIMPL	linux_readahead
 226	AUE_NULL	STD {
 		int linux_setxattr(
 		    const char *path,
 		    const char *name,
 		    const char *value,
 		    l_size_t size,
 		    l_int flags
 		);
 	}
 227	AUE_NULL	STD {
 		int linux_lsetxattr(
 		    const char *path,
 		    const char *name,
 		    const char *value,
 		    l_size_t size,
 		    l_int flags
 		);
 	}
 228	AUE_NULL	STD {
 		int linux_fsetxattr(
 		    l_int fd,
 		    const char *name,
 		    const char *value,
 		    l_size_t size,
 		    l_int flags
 		);
 	}
 229	AUE_NULL	STD {
 		int linux_getxattr(
 		    const char *path,
 		    const char *name,
 		    char *value,
 		    l_size_t size
 		);
 	}
 230	AUE_NULL	STD {
 		int linux_lgetxattr(
 		    const char *path,
 		    const char *name,
 		    char *value,
 		    l_size_t size
 		);
 	}
 231	AUE_NULL	STD {
 		int linux_fgetxattr(
 		    l_int fd,
 		    const char *name,
 		    char *value,
 		    l_size_t size
 		);
 	}
 232	AUE_NULL	STD {
 		int linux_listxattr(
 		    const char *path,
 		    const char *list,
 		    l_size_t size
 		);
 	}
 233	AUE_NULL	STD {
 		int linux_llistxattr(
 		    const char *path,
 		    const char *list,
 		    l_size_t size
 		);
 	}
 234	AUE_NULL	STD {
 		int linux_flistxattr(
 		    l_int fd,
 		    const char *list,
 		    l_size_t size
 		);
 	}
 235	AUE_NULL	STD {
 		int linux_removexattr(
 		    const char *path,
 		    const char *name
 		);
 	}
 236	AUE_NULL	STD {
 		int linux_lremovexattr(
 		    const char *path,
 		    const char *name
 		);
 	}
 237	AUE_NULL	STD {
 		int linux_fremovexattr(
 		    l_int fd,
 		    const char *name
 		);
 	}
 238	AUE_NULL	STD {
 		int linux_tkill(
 		    int tid,
 		    int sig
 		);
 	}
 239	AUE_SENDFILE	STD {
 		int linux_sendfile64(
 		    l_int out,
 		    l_int in,
 		    l_loff_t *offset,
 		    l_size_t count
 		);
 	}
 240	AUE_NULL	STD {
 		int linux_sys_futex(
 		    uint32_t *uaddr,
 		    l_int op,
 		    uint32_t val,
 		    struct l_timespec *timeout,
 		    uint32_t *uaddr2,
 		    uint32_t val3
 		);
 	}
 241	AUE_NULL	STD {
 		int linux_sched_setaffinity(
 		    l_pid_t pid,
 		    l_uint len,
 		    l_ulong *user_mask_ptr
 		);
 	}
 242	AUE_NULL	STD {
 		int linux_sched_getaffinity(
 		    l_pid_t pid,
 		    l_uint len,
 		    l_ulong *user_mask_ptr
 		);
 	}
 243	AUE_NULL	STD {
 		int linux_set_thread_area(
 		    struct l_user_desc *desc
 		);
 	}
 244	AUE_NULL	UNIMPL	linux_get_thread_area
 245	AUE_NULL	UNIMPL	linux_io_setup
 246	AUE_NULL	UNIMPL	linux_io_destroy
 247	AUE_NULL	UNIMPL	linux_io_getevents
 248	AUE_NULL	UNIMPL	linux_io_submit
 249	AUE_NULL	UNIMPL	linux_io_cancel
 250	AUE_NULL	STD {
 		int linux_fadvise64(
 		    int fd,
 		    uint32_t offset1,
 		    uint32_t offset2,
 		    l_size_t len,
 		    int advice
 		);
 	}
 251	AUE_NULL	UNIMPL
 252	AUE_EXIT	STD {
 		int linux_exit_group(
 		    int error_code
 		);
 	}
 253	AUE_NULL	STD {
 		int linux_lookup_dcookie(void);
 	}
 254	AUE_NULL	STD {
 		int linux_epoll_create(
 		    l_int size
 		);
 	}
 255	AUE_NULL	STD {
 		int linux_epoll_ctl(
 		    l_int epfd,
 		    l_int op,
 		    l_int fd,
 		    struct epoll_event *event
 		);
 	}
 256	AUE_NULL	STD {
 		int linux_epoll_wait(
 		    l_int epfd,
 		    struct epoll_event *events,
 		    l_int maxevents,
 		    l_int timeout
 		);
 	}
 257	AUE_NULL	STD {
 		int linux_remap_file_pages(void);
 	}
 258	AUE_NULL	STD {
 		int linux_set_tid_address(
 		    int *tidptr
 		);
 	}
 259	AUE_NULL	STD {
 		int linux_timer_create(
 		    clockid_t clock_id,
 		    struct sigevent *evp,
 		    l_timer_t *timerid
 		);
 	}
 260	AUE_NULL	STD {
 		int linux_timer_settime(
 		    l_timer_t timerid,
 		    l_int flags,
 		    const struct itimerspec *new,
 		    struct itimerspec *old
 		);
 	}
 261	AUE_NULL	STD {
 		int linux_timer_gettime(
 		    l_timer_t timerid,
 		    struct itimerspec *setting
 		);
 	}
 262	AUE_NULL	STD {
 		int linux_timer_getoverrun(
 		    l_timer_t timerid
 		);
 	}
 263	AUE_NULL	STD {
 		int linux_timer_delete(
 		    l_timer_t timerid
 		);
 	}
 264	AUE_CLOCK_SETTIME	STD {
 		int linux_clock_settime(
 		    clockid_t which,
 		    struct l_timespec *tp
 		);
 	}
 265	AUE_NULL	STD {
 		int linux_clock_gettime(
 		    clockid_t which,
 		    struct l_timespec *tp
 		);
 	}
 266	AUE_NULL	STD {
 		int linux_clock_getres(
 		    clockid_t which,
 		    struct l_timespec *tp
 		);
 	}
 267	AUE_NULL	STD {
 		int linux_clock_nanosleep(
 		    clockid_t which,
 		    int flags,
 		    struct l_timespec *rqtp,
 		    struct l_timespec *rmtp
 		);
 	}
 268	AUE_STATFS	STD {
 		int linux_statfs64(
 		    char *path,
 		    size_t bufsize,
 		    struct l_statfs64_buf *buf
 		);
 	}
 269	AUE_FSTATFS	STD {
 		int linux_fstatfs64(
 		    l_uint fd,
 		    size_t bufsize,
 		    struct l_statfs64_buf *buf
 		);
 	}
 270	AUE_NULL	STD {
 		int linux_tgkill(
 		    int tgid,
 		    int pid,
 		    int sig
 		);
 	}
 271	AUE_UTIMES	STD {
 		int linux_utimes(
 		    char *fname,
 		    struct l_timeval *tptr
 		);
 	}
 272	AUE_NULL	STD {
 		int linux_fadvise64_64(
 		    int fd,
 		    uint32_t offset1,
 		    uint32_t offset2,
 		    uint32_t len1,
 		    uint32_t len2,
 		    int advice
 		);
 	}
 273	AUE_NULL	UNIMPL	vserver
 274	AUE_NULL	STD {
 		int linux_mbind(void);
 	}
 275	AUE_NULL	STD {
 		int linux_get_mempolicy(void);
 	}
 276	AUE_NULL	STD {
 		int linux_set_mempolicy(void);
 	}
 ; Linux 2.6.6:
 277	AUE_NULL	STD {
 		int linux_mq_open(
 		    const char *name,
 		    l_int oflag,
 		    l_mode_t mode,
 		    struct mq_attr *attr
 		);
 	}
 278	AUE_NULL	STD {
 		int linux_mq_unlink(
 		    const char *name
 		);
 	}
 279	AUE_NULL	STD {
 		int linux_mq_timedsend(
 		    l_mqd_t mqd,
 		    const char *msg_ptr,
 		    l_size_t msg_len,
 		    l_uint msg_prio,
 		    const struct l_timespec *abs_timeout
 		);
 	}
 280	AUE_NULL	STD {
 		int linux_mq_timedreceive(
 		    l_mqd_t mqd,
 		    char *msg_ptr,
 		    l_size_t msg_len,
 		    l_uint *msg_prio,
 		    const struct l_timespec *abs_timeout
 		);
 	}
 281	AUE_NULL	STD {
 		int linux_mq_notify(
 		    l_mqd_t mqd,
 		    const struct l_timespec *abs_timeout
 		);
 	}
 282	AUE_NULL	STD {
 		int linux_mq_getsetattr(
 		    l_mqd_t mqd,
 		    const struct mq_attr *attr,
 		    struct mq_attr *oattr
 		);
 	}
 283	AUE_NULL	STD {
 		int linux_kexec_load(void);
 	}
 284	AUE_WAIT6	STD {
 		int linux_waitid(
 		    int idtype,
 		    l_pid_t id,
 		    l_siginfo_t *info,
 		    int options,
 		    struct l_rusage *rusage
 		);
 	}
 285	AUE_NULL	UNIMPL
 ; Linux 2.6.11:
 286	AUE_NULL	STD {
 		int linux_add_key(void);
 	}
 287	AUE_NULL	STD {
 		int linux_request_key(void);
 	}
 288	AUE_NULL	STD {
 		int linux_keyctl(void);
 	}
 ; Linux 2.6.13:
 289	AUE_NULL	STD {
 		int linux_ioprio_set(void);
 	}
 290	AUE_NULL	STD {
 		int linux_ioprio_get(void);
 	}
 291	AUE_NULL	STD {
 		int linux_inotify_init(void);
 	}
 292	AUE_NULL	STD {
 		int linux_inotify_add_watch(void);
 	}
 293	AUE_NULL	STD {
 		int linux_inotify_rm_watch(void);
 	}
 ; Linux 2.6.16:
 294	AUE_NULL	STD {
 		int linux_migrate_pages(void);
 	}
 295	AUE_OPEN_RWTC	STD {
 		int linux_openat(
 		    l_int dfd,
 		    const char *filename,
 		    l_int flags,
 		    l_int mode
 		);
 	}
 296	AUE_MKDIRAT	STD {
 		int linux_mkdirat(
 		    l_int dfd,
 		    const char *pathname,
 		    l_int mode
 		);
 	}
 297	AUE_MKNODAT	STD {
 		int linux_mknodat(
 		    l_int dfd,
 		    const char *filename,
 		    l_int mode,
 		    l_uint dev
 		);
 	}
 298	AUE_FCHOWNAT	STD {
 		int linux_fchownat(
 		    l_int dfd,
 		    const char *filename,
 		    l_uid16_t uid,
 		    l_gid16_t gid,
 		    l_int flag
 		);
 	}
 299	AUE_FUTIMESAT	STD {
 		int linux_futimesat(
 		    l_int dfd,
 		    char *filename,
 		    struct l_timeval *utimes
 		);
 	}
 300	AUE_FSTATAT	STD {
 		int linux_fstatat64(
 		    l_int dfd,
 		    char *pathname,
 		    struct l_stat64 *statbuf,
 		    l_int flag
 		);
 	}
 301	AUE_UNLINKAT	STD {
 		int linux_unlinkat(
 		    l_int dfd,
 		    const char *pathname,
 		    l_int flag
 		);
 	}
 302	AUE_RENAMEAT	STD {
 		int linux_renameat(
 		    l_int olddfd,
 		    const char *oldname,
 		    l_int newdfd,
 		    const char *newname
 		);
 	}
 303	AUE_LINKAT	STD {
 		int linux_linkat(
 		    l_int olddfd,
 		    const char *oldname,
 		    l_int newdfd,
 		    const char *newname,
 		    l_int flag
 		);
 	}
 304	AUE_SYMLINKAT	STD {
 		int linux_symlinkat(
 		    const char *oldname,
 		    l_int newdfd,
 		    const char *newname
 		);
 	}
 305	AUE_READLINKAT	STD {
 		int linux_readlinkat(
 		    l_int dfd,
 		    const char *path,
 		    char *buf,
 		    l_int bufsiz
 		);
 	}
 306	AUE_FCHMODAT	STD {
 		int linux_fchmodat(
 		    l_int dfd,
 		    const char *filename,
 		    l_mode_t mode
 		);
 	}
 307	AUE_FACCESSAT	STD {
 		int linux_faccessat(
 		    l_int dfd,
 		    const char *filename,
 		    l_int amode
 		);
 	}
 308	AUE_SELECT	STD {
 		int linux_pselect6(
 		    l_int nfds,
 		    l_fd_set *readfds,
 		    l_fd_set *writefds,
 		    l_fd_set *exceptfds,
 		    struct l_timespec *tsp,
 		    l_uintptr_t *sig
 		);
 	}
 309	AUE_POLL	STD {
 		int linux_ppoll(
 		    struct pollfd *fds,
 		    uint32_t nfds,
 		    struct l_timespec *tsp,
 		    l_sigset_t *sset,
 		    l_size_t ssize
 		);
 	}
 310	AUE_NULL	STD {
 		int linux_unshare(void);
 	}
 ; Linux 2.6.17:
 311	AUE_NULL	STD {
 		int linux_set_robust_list(
 		    struct linux_robust_list_head *head,
 		    l_size_t len
 		);
 	}
 312	AUE_NULL	STD {
 		int linux_get_robust_list(
 		    l_int pid,
 		    struct linux_robust_list_head **head,
 		    l_size_t *len
 		);
 	}
 313	AUE_NULL	STD {
 		int linux_splice(
 		    int fd_in,
 		    l_loff_t *off_in,
 		    int fd_out,
 		    l_loff_t *off_out,
 		    l_size_t len,
 		    l_uint flags
 		);
 	}
 314	AUE_NULL	STD {
 		int linux_sync_file_range(
 		    l_int fd,
 		    uint32_t offset1,
 		    uint32_t offset2,
 		    uint32_t nbytes1,
 		    uint32_t nbytes2,
 		    unsigned int flags
 		);
 	}
 315	AUE_NULL	STD {
 		int linux_tee(void);
 	}
 316	AUE_NULL	STD {
 		int linux_vmsplice(void);
 	}
 ; Linux 2.6.18:
 317	AUE_NULL	STD {
 		int linux_move_pages(void);
 	}
 ; Linux 2.6.19:
 318	AUE_NULL	STD {
 		int linux_getcpu(
 		    l_uint *cpu,
 		    l_uint *node,
 		    void *cache
 		);
 	}
 319	AUE_NULL	STD {
 		int linux_epoll_pwait(
 		    l_int epfd,
 		    struct epoll_event *events,
 		    l_int maxevents,
 		    l_int timeout,
 		    l_sigset_t *mask,
 		    l_size_t sigsetsize
 		);
 	}
 ; Linux 2.6.22:
 320	AUE_FUTIMESAT	STD {
 		int linux_utimensat(
 		    l_int dfd,
 		    const char *pathname,
 		    const struct l_timespec *times,
 		    l_int flags
 		);
 	}
 321	AUE_NULL	STD {
 		int linux_signalfd(void);
 	}
 322	AUE_NULL	STD {
 		int linux_timerfd_create(
 		    l_int clockid,
 		    l_int flags
 		);
 	}
 323	AUE_NULL	STD {
 		int linux_eventfd(
 		    l_uint initval
 		);
 	}
 ; Linux 2.6.23:
 324	AUE_NULL	STD {
 		int linux_fallocate(
 		    l_int fd,
 		    l_int mode,
 		    uint32_t offset1,
 		    uint32_t offset2,
 		    uint32_t len1,
 		    uint32_t len2
 		);
 	}
 ; Linux 2.6.25:
 325	AUE_NULL	STD {
 		int linux_timerfd_settime(
 		    l_int fd,
 		    l_int flags,
 		    const struct l_itimerspec *new_value,
 		    struct l_itimerspec *old_value
 		);
 	}
 326	AUE_NULL	STD {
 		int linux_timerfd_gettime(
 		    l_int fd,
 		    struct l_itimerspec *old_value
 		);
 	}
 ; Linux 2.6.27:
 327	AUE_NULL	STD {
 		int linux_signalfd4(void);
 	}
 328	AUE_NULL	STD {
 		int linux_eventfd2(
 		    l_uint initval,
 		    l_int flags
 		);
 	}
 329	AUE_NULL	STD {
 		int linux_epoll_create1(
 		    l_int flags
 		);
 	}
 330	AUE_NULL	STD {
 		int linux_dup3(
 		    l_int oldfd,
 		    l_int newfd,
 		    l_int flags
 		);
 	}
 331	AUE_NULL	STD {
 		int linux_pipe2(
 		    l_int *pipefds,
 		    l_int flags
 		);
 	}
 332	AUE_NULL	STD {
 		int linux_inotify_init1(void);
 	}
 ; Linux 2.6.30:
 333	AUE_NULL	STD {
 		int linux_preadv(
 		    l_ulong fd,
 		    struct iovec *vec,
 		    l_ulong vlen,
 		    l_ulong pos_l,
 		    l_ulong pos_h
 		);
 	}
 334	AUE_NULL	STD {
 		int linux_pwritev(
 		    l_ulong fd,
 		    struct iovec *vec,
 		    l_ulong vlen,
 		    l_ulong pos_l,
 		    l_ulong pos_h
 		);
 	}
 ; Linux 2.6.31:
 335	AUE_NULL	STD {
 		int linux_rt_tgsigqueueinfo(
 		    l_pid_t tgid,
 		    l_pid_t tid,
 		    l_int sig,
 		    l_siginfo_t *uinfo
 		);
 	}
 336	AUE_NULL	STD {
 		int linux_perf_event_open(void);
 	}
 ; Linux 2.6.33:
 337	AUE_NULL	STD {
 		int linux_recvmmsg(
 		    l_int s,
 		    struct l_mmsghdr *msg,
 		    l_uint vlen,
 		    l_uint flags,
 		    struct l_timespec *timeout
 		);
 	}
 338	AUE_NULL	STD {
 		int linux_fanotify_init(void);
 	}
 339	AUE_NULL	STD {
 		int linux_fanotify_mark(void);
 	}
 ; Linux 2.6.36:
 340	AUE_NULL	STD {
 		int linux_prlimit64(
 		    l_pid_t pid,
 		    l_uint resource,
 		    struct rlimit *new,
 		    struct rlimit *old
 		);
 	}
 ; Linux 2.6.39:
 341	AUE_NULL	STD {
 		int linux_name_to_handle_at(
 		    l_int dirfd,
 		    const char *name,
 		    struct l_file_handle *handle,
 		    l_int *mnt_id,
 		    l_int flags
 		);
 	}
 342	AUE_NULL	STD {
 		int linux_open_by_handle_at(
 		    l_int mountdirfd,
 		    struct l_file_handle *handle,
 		    l_int flags
 		);
 	}
 343	AUE_NULL	STD {
 		int linux_clock_adjtime(void);
 	}
 344	AUE_SYNC	STD {
 		int linux_syncfs(
 		    l_int fd
 		);
 	}
 ; Linux 3.0:
 345	AUE_NULL	STD {
 		int linux_sendmmsg(
 		    l_int s,
 		    struct l_mmsghdr *msg,
 		    l_uint vlen,
 		    l_uint flags
 		);
 	}
 346	AUE_NULL	STD {
 		int linux_setns(void);
 	}
 ; Linux 3.2 (glibc 2.15):
 347	AUE_NULL	STD {
 		int linux_process_vm_readv(
 		    l_pid_t pid,
 		    const struct iovec *lvec,
 		    l_ulong liovcnt,
 		    const struct iovec *rvec,
 		    l_ulong riovcnt,
 		    l_ulong flags
 		);
 	}
 348	AUE_NULL	STD {
 		int linux_process_vm_writev(
 		    l_pid_t pid,
 		    const struct iovec *lvec,
 		    l_ulong liovcnt,
 		    const struct iovec *rvec,
 		    l_ulong riovcnt,
 		    l_ulong flags
 		);
 	}
 ; Linux 3.5 (no glibc wrapper):
 349	AUE_NULL	STD {
 		int linux_kcmp(
 		    l_pid_t pid1,
 		    l_pid_t pid2,
 		    l_int type,
 		    l_ulong idx1,
 		    l_ulong idx
 		);
 	}
 ; Linux 3.8 (no glibc wrapper):
 350	AUE_NULL	STD {
 		int linux_finit_module(
 		    l_int fd,
 		    const char *uargs,
 		    l_int flags
 		);
 	}
 ; Linux 3.14:
 351	AUE_NULL	STD {
 		int linux_sched_setattr(
 		    l_pid_t pid,
 		    void *attr,
 		    l_uint flags
 		);
 	}
 352	AUE_NULL	STD {
 		int linux_sched_getattr(
 		    l_pid_t pid,
 		    void *attr,
 		    l_uint size,
 		    l_uint flags
 		);
 	}
 ; Linux 3.15:
 353	AUE_NULL	STD {
 		int linux_renameat2(
 		    l_int olddfd,
 		    const char *oldname,
 		    l_int newdfd,
 		    const char *newname,
 		    unsigned int flags
 		);
 	}
 ; Linux 3.17:
 354	AUE_NULL	STD {
 		int linux_seccomp(
 		    l_uint op,
 		    l_uint flags,
 		    const char *uargs
 		);
 	}
 355	AUE_NULL	STD {
 		int linux_getrandom(
 		    char *buf,
 		    l_size_t count,
 		    l_uint flags
 		);
 	}
 356	AUE_NULL	STD {
 		int linux_memfd_create(
 		    const char *uname_ptr,
 		    l_uint flags
 		);
 	}
 ; Linux 3.18:
 357	AUE_NULL	STD {
 		int linux_bpf(
 		    l_int cmd,
 		    void *attr,
 		    l_uint size
 		);
 	}
 ; Linux 3.19:
 358	AUE_NULL	STD {
 		int linux_execveat(
 		    l_int dfd,
 		    const char *filename,
 		    const char **argv,
 		    const char **envp,
 		    l_int flags
 		);
 	}
 ; Linux 4.3: sockets now direct system calls:
 359	AUE_SOCKET	STD {
 		int linux_socket(
 		    l_int domain,
 		    l_int type,
 		    l_int protocol
 		);
 	}
 360	AUE_SOCKETPAIR	STD {
 		int linux_socketpair(
 		    l_int domain,
 		    l_int type,
 		    l_int protocol,
 		    l_uintptr_t rsv
 		);
 	}
 361	AUE_BIND	STD {
 		int linux_bind(
 		    l_int s,
 		    l_uintptr_t name,
 		    l_int namelen
 		);
 	}
 362	AUE_CONNECT	STD {
 		int linux_connect(
 		    l_int s,
 		    l_uintptr_t name,
 		    l_int namelen
 		);
 	}
 363	AUE_LISTEN	STD {
 		int linux_listen(
 		    l_int s,
 		    l_int backlog
 		);
 	}
 364	AUE_ACCEPT	STD {
 		int linux_accept4(
 		    l_int s,
 		    l_uintptr_t addr,
 		    l_uintptr_t namelen,
 		    l_int flags
 		);
 	}
 365	AUE_GETSOCKOPT	STD {
 		int linux_getsockopt(
 		    l_int s,
 		    l_int level,
 		    l_int optname,
 		    l_uintptr_t optval,
 		    l_uintptr_t optlen
 		);
 	}
 366	AUE_SETSOCKOPT	STD {
 		int linux_setsockopt(
 		    l_int s,
 		    l_int level,
 		    l_int optname,
 		    l_uintptr_t optval,
 		    l_int optlen
 		);
 	}
 367	AUE_GETSOCKNAME	STD {
 		int linux_getsockname(
 		    l_int s,
 		    l_uintptr_t addr,
 		    l_uintptr_t namelen
 		);
 	}
 368	AUE_GETPEERNAME	STD {
 		int linux_getpeername(
 		    l_int s,
 		    l_uintptr_t addr,
 		    l_uintptr_t namelen
 		);
 	}
 369	AUE_SENDTO	STD {
 		int linux_sendto(
 		    l_int s,
 		    l_uintptr_t msg,
 		    l_int len,
 		    l_int flags,
 		    l_uintptr_t to,
 		    l_int tolen
 		);
 	}
 370	AUE_SENDMSG	STD {
 		int linux_sendmsg(
 		    l_int s,
 		    l_uintptr_t msg,
 		    l_int flags
 		);
 	}
 371	AUE_RECVFROM	STD {
 		int linux_recvfrom(
 		    l_int s,
 		    l_uintptr_t buf,
 		    l_size_t len,
 		    l_int flags,
 		    l_uintptr_t from,
 		    l_uintptr_t fromlen
 		);
 	}
 372	AUE_RECVMSG	STD {
 		int linux_recvmsg(
 		    l_int s,
 		    l_uintptr_t msg,
 		    l_int flags
 		);
 	}
 373	AUE_NULL	STD {
 		int linux_shutdown(
 		    l_int s,
 		    l_int how
 		);
 	}
 ; Linux 4.2:
 374	AUE_NULL	STD {
 		int linux_userfaultfd(
 		    l_int flags
 		);
 	}
 ; Linux 4.3:
 375	AUE_NULL	STD {
 		int linux_membarrier(
 		    l_int cmd,
 		    l_int flags
 		);
 	}
 ; Linux 4.4:
 376	AUE_NULL	STD {
 		int linux_mlock2(
 		    l_ulong start,
 		    l_size_t len,
 		    l_int flags
 		);
 	}
 ; Linux 4.5:
 377	AUE_NULL	STD {
 		int linux_copy_file_range(
 		    l_int fd_in,
 		    l_loff_t *off_in,
 		    l_int fd_out,
 		    l_loff_t *off_out,
 		    l_size_t len,
 		    l_uint flags
 		);
 	}
 ; Linux 4.6:
 378	AUE_NULL	STD {
 		int linux_preadv2(
 		    l_ulong fd,
 		    const struct iovec *vec,
 		    l_ulong vlen,
 		    l_ulong pos_l,
 		    l_ulong pos_h,
 		    l_int flags
 		);
 	}
 379	AUE_NULL	STD {
 		int linux_pwritev2(
 		    l_ulong fd,
 		    const struct iovec *vec,
 		    l_ulong vlen,
 		    l_ulong pos_l,
 		    l_ulong pos_h,
 		    l_int flags
 		);
 	}
 ; Linux 4.8:
 380	AUE_NULL	STD {
 		int linux_pkey_mprotect(
 		    l_ulong start,
 		    l_size_t len,
 		    l_ulong prot,
 		    l_int pkey
 		);
 	}
 381	AUE_NULL	STD {
 		int linux_pkey_alloc(
 		    l_ulong flags,
 		    l_ulong init_val
 		);
 	}
 382	AUE_NULL	STD {
 		int linux_pkey_free(
 		    l_int pkey
 		);
 	}
 ; Linux 4.11:
 383	AUE_NULL	STD {
 		int linux_statx(
 		    l_int dirfd,
 		    const char *pathname,
 		    l_uint flags,
 		    l_uint mask,
 		    void *statxbuf
 		);
 	}
 384	AUE_NULL	STD {
 		int linux_arch_prctl(
 		    l_int option,
 		    l_ulong arg2
 		);
 	}
 ; Linux 4.18:
 385	AUE_NULL	STD {
 		int linux_io_pgetevents(void);
 	}
 386	AUE_NULL	STD {
 		int linux_rseq(void);
 	}
 387-392	AUE_NULL	UNIMPL	nosys
 393	AUE_NULL	STD {
 		int linux_semget(
 		    l_key_t key,
 		    l_int nsems,
 		    l_int semflg
 		);
 	}
 394	AUE_NULL	STD {
 		int linux_semctl(
 		    l_int semid,
 		    l_int semnum,
 		    l_int cmd,
 		    union l_semun arg
 		);
 	}
 395	AUE_NULL	STD {
 		int linux_shmget(
 		    l_key_t key,
 		    l_size_t size,
 		    l_int shmflg
 		);
 	}
 396	AUE_NULL	STD {
 		int linux_shmctl(
 		    l_int shmid,
 		    l_int cmd,
 		    struct l_shmid_ds *buf
 		);
 	}
 397	AUE_NULL	STD {
 		int linux_shmat(
 		    l_int shmid,
 		    char *shmaddr,
 		    l_int shmflg
 		);
 	}
 398	AUE_NULL	STD {
 		int linux_shmdt(
 		    char *shmaddr
 		);
 	}
 399	AUE_NULL	STD {
 		int linux_msgget(
 		    l_key_t key,
 		    l_int msgflg
 		);
 	}
 400	AUE_NULL	STD {
 		int linux_msgsnd(
 		    l_int msqid,
 		    struct l_msgbuf *msgp,
 		    l_size_t msgsz,
 		    l_int msgflg
 		);
 	}
 401	AUE_NULL	STD {
 		int linux_msgrcv(
 		    l_int msqid,
 		    struct l_msgbuf *msgp,
 		    l_size_t msgsz,
 		    l_long msgtyp,
 		    l_int msgflg
 		);
 	}
 402	AUE_NULL	STD {
 		int linux_msgctl(
 		    l_int msqid,
 		    l_int cmd,
 		    struct l_msqid_ds *buf
 		);
 	}
 ; Linux 5.0:
 403	AUE_NULL	STD {
 		int linux_clock_gettime64(
 		    clockid_t which,
 		    struct l_timespec64 *tp
 		);
 	}
 404	AUE_NULL	STD {
 		int linux_clock_settime64(
 		    clockid_t which,
 		    struct l_timespec64 *tp
 		);
 	}
 405	AUE_NULL	STD {
 		int linux_clock_adjtime64(void);
 	}
 406	AUE_NULL	STD {
 		int linux_clock_getres_time64(
 		    clockid_t which,
 		    struct l_timespec64 *tp
 		);
 	}
 407	AUE_NULL	STD {
 		int linux_clock_nanosleep_time64(
 		    clockid_t which,
 		    l_int flags,
 		    struct l_timespec64 *rqtp,
 		    struct l_timespec64 *rmtp
 		);
 	}
 408	AUE_NULL	STD {
 		int linux_timer_gettime64(void);
 	}
 409	AUE_NULL	STD {
 		int linux_timer_settime64(void);
 	}
 410	AUE_NULL	STD {
 		int linux_timerfd_gettime64(void);
 	}
 411	AUE_NULL	STD {
 		int linux_timerfd_settime64(void);
 	}
 412	AUE_NULL	STD {
 		int linux_utimensat_time64(
 		    l_int dfd,
 		    const char *pathname,
 		    const struct l_timespec64 *times64,
 		    l_int flags
 		);
 	}
 413	AUE_NULL	STD {
 		int linux_pselect6_time64(
 		    l_int nfds,
 		    l_fd_set *readfds,
 		    l_fd_set *writefds,
 		    l_fd_set *exceptfds,
 		    struct l_timespec64 *tsp,
 		    l_uintptr_t *sig
 		);
 	}
 414	AUE_NULL	STD {
 		int linux_ppoll_time64(
 		    struct pollfd *fds,
 		    uint32_t nfds,
 		    struct l_timespec *tsp,
 		    l_sigset_t *sset,
 		    l_size_t ssize
 		);
 	}
 415	AUE_NULL	UNIMPL	nosys
 416	AUE_NULL	STD {
 		int linux_io_pgetevents_time64(void);
 	}
 417	AUE_NULL	STD {
 		int linux_recvmmsg_time64(void);
 	}
 418	AUE_NULL	STD {
 		int linux_mq_timedsend_time64(void);
 	}
 419	AUE_NULL	STD {
 		int linux_mq_timedreceive_time64(void);
 	}
 420	AUE_NULL	STD {
 		int linux_semtimedop_time64(void);
 	}
 421	AUE_NULL	STD {
 		int linux_rt_sigtimedwait_time64(
 		    l_sigset_t *mask,
 		    l_siginfo_t *ptr,
 		    struct l_timespec64 *timeout,
 		    l_size_t sigsetsize
 		);
 	}
 422	AUE_NULL	STD {
 		int linux_sys_futex_time64(
 		    uint32_t *uaddr,
 		    l_int op,
 		    uint32_t val,
 		    struct l_timespec64 *timeout,
 		    uint32_t *uaddr2,
 		    uint32_t val3
 		);
 	}
 423	AUE_NULL	STD {
 		int linux_sched_rr_get_interval_time64(void);
 	}
 424	AUE_NULL	STD {
 		int linux_pidfd_send_signal(
 		    l_int pidfd,
 		    l_int sig,
 		    l_siginfo_t *info,
 		    l_uint flags
 		);
 	}
 425	AUE_NULL	STD {
 		int linux_io_uring_setup(void);
 	}
 426	AUE_NULL	STD {
 		int linux_io_uring_enter(void);
 	}
 427	AUE_NULL	STD {
 		int linux_io_uring_register(void);
 	}
 428    AUE_NULL		STD {
 		int linux_open_tree(void);
 	}
 429    AUE_NULL		STD {
 		int linux_move_mount(void);
 	}
 430    AUE_NULL		STD {
 		int linux_fsopen(void);
 	}
 431    AUE_NULL		STD {
 		int linux_fsconfig(void);
 	}
 432    AUE_NULL		STD {
 		int linux_fsmount(void);
 	}
 433    AUE_NULL		STD {
 		int linux_fspick(void);
 	}
 434    AUE_NULL		STD {
 		int linux_pidfd_open(void);
 	}
 435    AUE_NULL		STD {
 		int linux_clone3(void);
 	}
 436    AUE_NULL		STD {
 		int linux_close_range(void);
 	}
 437    AUE_NULL		STD {
 		int linux_openat2(void);
 	}
 438    AUE_NULL		STD {
 		int linux_pidfd_getfd(void);
 	}
 439    AUE_NULL		STD {
 		int linux_faccessat2(void);
 	}
 440    AUE_NULL		STD {
 		int linux_process_madvise(void);
 	}
 441    AUE_NULL		STD {
 		int linux_epoll_pwait2(void);
 	}
 442    AUE_NULL		STD {
 		int linux_mount_setattr(void);
 	}
 ; please, keep this line at the end.
 443    AUE_NULL        UNIMPL  nosys
 ; vim: syntax=off
diff --git a/sys/arm/linux/syscalls.master b/sys/arm/linux/syscalls.master
index 42adc18bbe1e..46cf988c3dfe 100644
--- a/sys/arm/linux/syscalls.master
+++ b/sys/arm/linux/syscalls.master
@@ -1,1929 +1,1929 @@
  $FreeBSD$
 
 ; Linux ABI system call name/number map, based on Linux file
 ; arch/arm/kernel/calls.S
 
 #include <sys/param.h>
 #include <sys/sysent.h>
 #include <sys/sysproto.h>
 #include <compat/linux/linux_sysproto.h>
 #include <arm/linux/linux.h>
 #include <arm/linux/linux_proto.h>
 
 ; Isn't pretty, but there seems to be no other way to trap nosys
 #define	nosys	linux_nosys
 
 0	AUE_NULL	UNIMPL	setup
 1	AUE_EXIT	STD	{
 		void linux_exit(
 		    int rval
 		);
 	}
 2	AUE_FORK	STD	{
 		int linux_fork(void);
 	}
 3	AUE_NULL	NOPROTO	{
 		int read(
 		    int fd,
 		    char *buf,
 		    u_int nbyte
 		);
 	}
 4	AUE_NULL	NOPROTO	{
 		int write(
 		    int fd,
 		    char *buf,
 		    u_int nbyte
 		);
 	}
 5	AUE_OPEN_RWTC	STD	{
 		int linux_open(
 		    char *path,
 		    l_int flags,
 		    l_int mode
 		);
 	}
 6	AUE_CLOSE	NOPROTO	{
 		int close(
 		    int fd);
 	}
 7	AUE_NULL	UNIMPL  ; was linux_waitpid
 8	AUE_CREAT	STD	{
 		int linux_creat(
 		    char *path,
 		    l_int mode
 		);
 	}
 9	AUE_LINK	STD	{
 		int linux_link(
 		    char *path,
 		    char *to
 		);
 	}
 10	AUE_UNLINK	STD	{
 		int linux_unlink(
 		    char *path
 		);
 	}
 11	AUE_EXECVE	STD	{
 		int linux_execve(
 		    char *path,
 		    char **argp,
 		    char **envp
 		);
 	}
 12	AUE_CHDIR	STD	{
 		int linux_chdir(
 		    char *path
 		);
 	}
 13	AUE_NULL	UNIMPL  ; was OBSOLETE(linux_time)
 14	AUE_MKNOD	STD	{
 		int linux_mknod(
 		    char *path,
 		    l_int mode,
 		    l_dev_t dev
 		);
 	}
 15	AUE_CHMOD	STD	{
 		int linux_chmod(
 		    char *path,
 		    l_mode_t mode
 		);
 	}
 16	AUE_LCHOWN	STD	{
 		int linux_lchown16(
 		    char *path,
 		    l_uid16_t uid,
 		    l_gid16_t gid);
 	}
 17	AUE_NULL	UNIMPL	; was linux_break
 18	AUE_NULL	UNIMPL  ; was linux_stat
 19	AUE_LSEEK	STD	{
 		int linux_lseek(
 		    l_uint fdes,
 		    l_off_t off,
 		    l_int whence
 		);
 	}
 20	AUE_GETPID	STD	{
 		int linux_getpid(void);
 	}
 21	AUE_MOUNT	STD	{
 		int linux_mount(
 		    char *specialfile,
 		    char *dir,
 		    char *filesystemtype,
 		    l_ulong rwflag,
 		    void *data
 		);
 	}
 22	AUE_NULL	UNIMPL  ; was OBSOLETE(linux_oldumount)
 23	AUE_SETUID	STD	{
 		int linux_setuid16(
 		    l_uid16_t uid);
 	}
 24	AUE_GETUID	STD	{
 		int linux_getuid16(void);
 	}
 25	AUE_NULL	UNIMPL  ; was OBSOLETE(linux_stime)
 26	AUE_PTRACE	UNIMPL	ptrace
 27	AUE_NULL	UNIMPL  ; was OBSOLETE(linux_alarm)
 28	AUE_NULL	UNIMPL  ; was linux_fstat
 29	AUE_NULL	STD	{
 		int linux_pause(void);
 	}
 30	AUE_NULL	UNIMPL  ; was OBSOLETE(linux_utime)
 31	AUE_NULL	UNIMPL  ; was linux_stty
 32	AUE_NULL	UNIMPL  ; was linux_getty
 33	AUE_ACCESS	STD	{
 		int linux_access(
 		    char *path,
 		    l_int amode
 		);
 	}
 34	AUE_NICE	STD	{
 		int linux_nice(
 		    l_int inc
 		);
 	}
 35	AUE_NULL	UNIMPL  ; was linux_ftime
 36	AUE_SYNC	NOPROTO	{
 		int sync(void);
 	}
 37	AUE_KILL	STD	{
 		int linux_kill(
 		    l_int pid,
 		    l_int signum
 		);
 	}
 38	AUE_RENAME	STD	{
 		int linux_rename(
 		    char *from,
 		    char *to
 		);
 	}
 39	AUE_MKDIR	STD	{
 		int linux_mkdir(
 		    char *path,
 		    l_int mode
 		);
 	}
 40	AUE_RMDIR	STD	{
 		int linux_rmdir(
 		    char *path
 		);
 	}
 41	AUE_DUP		NOPROTO	{
 		int dup(
 		    u_int fd);
 	}
 42	AUE_PIPE	STD	{
 		int linux_pipe(
 		    l_int *pipefds
 		);
 	}
 43	AUE_NULL	STD	{
 		int linux_times(
 		    struct l_times_argv *buf
 		);
 	}
 44	AUE_NULL	UNIMPL  ; was linux_prof
 45	AUE_NULL	STD	{
 		int linux_brk(
 		    l_ulong dsend);
 	}
 46	AUE_SETGID	STD	{
 		int linux_setgid16(
 		    l_gid16_t gid);
 	}
 47	AUE_GETGID	STD	{
 		int linux_getgid16(void);
 	}
 48	AUE_NULL	UNIMPL  ; was linux_signal
 49	AUE_GETEUID	STD	{
 		int linux_geteuid16(void);
 	}
 50	AUE_GETEGID	STD	{
 		int linux_getegid16(void);
 	}
 51	AUE_ACCT	NOPROTO	{
 		int acct(
 		    char *path
 		);
 	}
 52	AUE_UMOUNT	STD	{
 		int linux_umount(
 		    char *path,
 		    l_int flags
 		);
 	}
 53	AUE_NULL	UNIMPL  ; was linux_lock
 54	AUE_IOCTL	STD	{
 		int linux_ioctl(
 		    l_uint fd,
 		    l_uint cmd,
 		    l_ulong arg
 		);
 	}
 55	AUE_FCNTL	STD	{
 		int linux_fcntl(
 		    l_uint fd,
 		    l_uint cmd,
 		    l_ulong arg
 		);
 	}
 56	AUE_NULL	UNIMPL  ; was linux_mpx
 57	AUE_SETPGRP	NOPROTO	{
 		int setpgid(
 		    int pid,
 		    int pgid);
 	}
 58	AUE_NULL	UNIMPL  ; was linux_ulimit
 59	AUE_NULL	UNIMPL  ; was linux_olduname
 60	AUE_UMASK	NOPROTO	{
 		int umask(
 		    int newmask
 		);
 	}
 61	AUE_CHROOT	NOPROTO	{
 		int chroot(
 		    char *path
 		);
 	}
 62	AUE_NULL	STD	{
 		int linux_ustat(
 		    l_dev_t dev,
 		    struct l_ustat *ubuf
 		);
 	}
 63	AUE_DUP2	NOPROTO {
 		int dup2(
 		    u_int from,
 		    u_int to
 		);
 	}
 64	AUE_GETPPID	STD	{
 		int linux_getppid(void);
 	}
 65	AUE_GETPGRP	NOPROTO {
 		int getpgrp(void);
 	}
 66	AUE_SETSID	NOPROTO {
 		int setsid(void);
 	}
 67	AUE_NULL	STD	{
 		int linux_sigaction(
 		    l_int sig,
 		    l_osigaction_t *nsa,
 		    l_osigaction_t *osa
 		);
 	}
 68	AUE_NULL	UNIMPL  ; was linux_sgetmask
 69	AUE_NULL	UNIMPL  ; was linux_ssetmask
 70	AUE_SETREUID	STD	{
 		int linux_setreuid16(
 		    l_uid16_t ruid,
 		    l_uid16_t euid);
 	}
 71	AUE_SETREGID	STD	{
 		int linux_setregid16(
 		    l_gid16_t rgid,
 		    l_gid16_t egid);
 	}
 72	AUE_NULL	STD	{
 		int linux_sigsuspend(
 		    l_int hist0,
 		    l_int hist1,
 		    l_osigset_t mask
 		);
 	}
 73	AUE_NULL	STD	{
 		int linux_sigpending(
 		    l_osigset_t *mask
 		);
 	}
 74	AUE_SYSCTL	STD	{
 		int linux_sethostname(
 		    char *hostname,
 		    u_int len
 		);
 	}
 75	AUE_SETRLIMIT	STD	{
 		int linux_setrlimit(
 		    l_uint resource,
 		    struct l_rlimit *rlim
 		);
 	}
 76	AUE_NULL	UNIMPL  ; was OBSOLETE(linux_old_getrlimit)
 77	AUE_GETRUSAGE	NOPROTO	{
 		int getrusage(
 		    int who,
 		    struct rusage *rusage
 		);
 	}
 78	AUE_GETTIMEOFDAY	STD	{
 		int linux_gettimeofday(
 		    struct timeval32 *tp,
 		    struct timezone *tzp
 		);
 	}
 79	AUE_SETTIMEOFDAY	STD	{
 		int linux_settimeofday(
 		    struct timeval32 *tp,
 		    struct timezone *tzp
 		);
 	}
 80	AUE_GETGROUPS	STD	{
 		int linux_getgroups16(
 		    l_uint gidsetsize,
 		    l_gid16_t *gidset
 		);
 	}
 81	AUE_SETGROUPS	STD	{
 		int linux_setgroups16(
 		    l_uint gidsetsize,
 		    l_gid16_t *gidset
 		);
 	}
 82	AUE_NULL	UNIMPL  ; was OBSOLETE(linux_old_select)
 83	AUE_SYMLINK	STD	{
 		int linux_symlink(
 		    char *path,
 		    char *to
 		);
 	}
 84	AUE_NULL	UNIMPL  ; was linux_lstat
 85	AUE_READLINK	STD	{
 		int linux_readlink(
 		    char *name,
 		    char *buf,
 		    l_int count
 		);
 	}
 86	AUE_NULL	UNIMPL	uselib
 87	AUE_SWAPON	NOPROTO	{
 		int swapon(
 		    char *name
 		);
 	}
 88	AUE_REBOOT	STD	{
 		int linux_reboot(
 		    l_int magic1,
 		    l_int magic2,
 		    l_uint cmd,
 		    void *arg
 		);
 	}
 89	AUE_NULL	UNIMPL  ; was OBSOLETE(linux_old_readdir)
 90	AUE_NULL	UNIMPL  ; was OBSOLETE(linux_old_mmap)
 91	AUE_MUNMAP	NOPROTO	{
 		int munmap(
 		    caddr_t addr,
 		    int len
 		);
 	}
 92	AUE_TRUNCATE	STD	{
 		int linux_truncate(
 		    char *path,
 		    l_ulong length
 		);
 	}
 93	AUE_FTRUNCATE	STD	{
 		int linux_ftruncate(
 		    int fd,
 		    long length
 		);
 	}
 94	AUE_FCHMOD	NOPROTO	{
 		int fchmod(
 		    int fd,
 		    int mode
 		);
 	}
 95	AUE_FCHOWN	NOPROTO	{
 		int fchown(
 		    int fd,
 		    int uid,
 		    int gid);
 	}
 96	AUE_GETPRIORITY	STD	{
 		int linux_getpriority(
 		    int which,
 		    int who
 		);
 	}
 97	AUE_SETPRIORITY	NOPROTO	{
 		int setpriority(
 		    int which,
 		    int who,
 		    int prio
 		);
 	}
 98	AUE_NULL	UNIMPL  ; was linux_profil
 99	AUE_STATFS	STD	{
 		int linux_statfs(
 		    char *path,
 		    struct l_statfs_buf *buf
 		);
 	}
 100	AUE_FSTATFS	STD	{
 		int linux_fstatfs(
 		    l_uint fd,
 		    struct l_statfs_buf *buf
 		);
 	}
 101	AUE_NULL	UNIMPL	; was ioperm
 102	AUE_NULL	UNIMPL  ; was OBSOLETE(linux_socketcall)
 103	AUE_NULL	STD	{
 		int linux_syslog(
 		    l_int type,
 		    char *buf,
 		    l_int len
 		);
 	}
 104	AUE_SETITIMER	STD	{
 		int linux_setitimer(
 		    l_int which,
 		    struct l_itimerval *itv,
 		    struct l_itimerval *oitv
 		);
 	}
 105	AUE_GETITIMER	STD	{
 		int linux_getitimer(
 		    l_int which,
 		    struct l_itimerval *itv
 		);
 	}
 106	AUE_STAT	STD	{
 		int linux_newstat(
 		    char *path,
 		    struct l_newstat *buf
 		);
 	}
 107	AUE_LSTAT	STD	{
 		int linux_newlstat(
 		    char *path,
 		    struct l_newstat *buf
 		);
 	}
 108	AUE_FSTAT	STD	{
 		int linux_newfstat(
 		    l_uint fd,
 		    struct l_newstat *buf
 		);
 	}
 109	AUE_NULL	UNIMPL  ; was linux_uname
 110	AUE_NULL	UNIMPL	; was linux_iopl
 111	AUE_NULL	STD	{
 		int linux_vhangup(void);
 	}
 112	AUE_NULL	UNIMPL	;
 113	AUE_NULL	UNIMPL  ; was OBSOLETE(linux_syscall)
 114	AUE_WAIT4	STD	{
 		int linux_wait4(
 		    l_pid_t pid,
 		    l_int *status,
 		    l_int options,
 		    void *rusage
 		);
 	}
 115	AUE_SWAPOFF	STD	{
 		int linux_swapoff(void);
 	}
 116	AUE_NULL	STD	{
 		int linux_sysinfo(
 		    struct l_sysinfo *info
 		);
 	}
 117	AUE_NULL	UNIMPL  ; was OBSOLETE(linux_ipc)
 118	AUE_FSYNC	NOPROTO	{
 		int fsync(
 		    int fd);
 	}
 119	AUE_SIGRETURN	STD	{
 		int linux_sigreturn(
 		    struct l_sigframe *sfp
 		);
 	}
 120	AUE_RFORK	STD	{
 		int linux_clone(
 		    l_int flags,
 		    void *stack,
 		    void *parent_tidptr,
 		    void *tls,
 		    void * child_tidptr
 		);
 	}
 121	AUE_SYSCTL	STD	{
 		int linux_setdomainname(
 		    char *name,
 		    int len
 		);
 	}
 122	AUE_NULL	STD	{
 		int linux_newuname(
 		    struct l_new_utsname *buf
 		);
 	}
 123	AUE_NULL	UNIMPL	; was linux_modify_ldt
 124	AUE_ADJTIME	STD	{
 		int linux_adjtimex(void);
 	}
 125	AUE_MPROTECT	STD	{
 		int linux_mprotect(
 		    caddr_t addr,
 		    int len,
 		    int prot
 		);
 	}
 126	AUE_SIGPROCMASK	STD	{
 		int linux_sigprocmask(
 		    l_int how,
 		    l_osigset_t *mask,
 		    l_osigset_t *omask
 		);
 	}
 127	AUE_NULL	UNIMPL  ; was linux_create_module
 128	AUE_NULL	STD	{
 		int linux_init_module(void);
 	}
 129	AUE_NULL	STD	{
 		int linux_delete_module(void);
 	}
 130	AUE_NULL	UNIMPL  ; was linux_get_kernel_syms
 131	AUE_QUOTACTL	STD	{
 		int linux_quotactl(void);
 	}
 132	AUE_GETPGID	NOPROTO	{
 		int getpgid(
 		    int pid);
 	}
 133	AUE_FCHDIR	NOPROTO	{
 		int fchdir(
 		    int fd);
 	}
 134	AUE_BDFLUSH	STD	{
 		int linux_bdflush(void);
 	}
 135	AUE_NULL	STD	{
 		int linux_sysfs(
 		    l_int option,
 		    l_ulong arg1,
 		    l_ulong arg2
 		);
 	}
 136	AUE_PERSONALITY	STD	{
 		int linux_personality(
 		    l_ulong per
 		);
 	}
 137	AUE_NULL	UNIMPL	; was afs_syscall
 138	AUE_SETFSUID	STD	{
 		int linux_setfsuid16(
 		    l_uid16_t uid);
 	}
 139	AUE_SETFSGID	STD	{
 		int linux_setfsgid16(
 		    l_gid16_t gid);
 	}
 140	AUE_LSEEK	STD	{
 		int linux_llseek(
 		    l_int fd,
 		    l_ulong ohigh,
 		    l_ulong olow,
 		    l_loff_t *res,
 		    l_uint whence
 		);
 	}
 141	AUE_GETDIRENTRIES	STD {
 		int linux_getdents(
 		    l_uint fd,
 		    void *dent,
 		    l_uint count
 		);
 	}
 ; 142: newselect
 142	AUE_SELECT	STD	{
 		int linux_select(
 		    l_int nfds,
 		    l_fd_set *readfds,
 		    l_fd_set *writefds,
 		    l_fd_set *exceptfds,
 		    struct l_timeval *timeout
 		);
 	}
 143	AUE_FLOCK	NOPROTO	{
 		int flock(
 		    int fd,
 		    int how
 		);
 	}
 144	AUE_MSYNC	STD	{
 		int linux_msync(
 		    l_ulong addr,
 		    l_size_t len,
 		    l_int fl
 		);
 	}
 145	AUE_READV	NOPROTO	{
 		int readv(
 		    int fd,
 		    struct iovec *iovp,
 		    u_int iovcnt
 		);
 	}
 146	AUE_WRITEV	NOPROTO	{
 		int writev(
 		    int fd,
 		    struct iovec *iovp,
 		    u_int iovcnt
 		);
 	}
 147	AUE_GETSID	STD	{
 		int linux_getsid(
 		    l_pid_t pid);
 	}
 148	AUE_NULL	STD	{
 		int linux_fdatasync(
 		    l_uint fd);
 	}
 149	AUE_SYSCTL	STD	{
 		int linux_sysctl(
 		    struct l___sysctl_args *args
 		);
 	}
 150	AUE_MLOCK	NOPROTO	{
 		int mlock(
 		    const void *addr,
 		    size_t len
 		);
 	}
 151	AUE_MUNLOCK	NOPROTO	{
 		int munlock(
 		    const void *addr,
 		    size_t len
 		);
 	}
 152	AUE_MLOCKALL	NOPROTO	{
 		int mlockall(
 		    int how
 		);
 	}
 153	AUE_MUNLOCKALL	NOPROTO	{
 		int munlockall(void);
 	}
 154	AUE_SCHED_SETPARAM	STD	{
 		int linux_sched_setparam(
 		    l_pid_t pid,
 		    struct sched_param *param
 		);
 	}
 155	AUE_SCHED_GETPARAM	STD	{
 		int linux_sched_getparam(
 		    l_pid_t pid,
 		    struct sched_param *param
 		);
 	}
 156	AUE_SCHED_SETSCHEDULER	STD {
 		int linux_sched_setscheduler(
 		    l_pid_t pid,
 		    l_int policy,
 		    struct sched_param *param
 		);
 	}
 157	AUE_SCHED_GETSCHEDULER	STD {
 		int linux_sched_getscheduler(
 		    l_pid_t pid);
 	}
 158	AUE_NULL	NOPROTO	{
 		int sched_yield(void);
 	}
 159	AUE_SCHED_GET_PRIORITY_MAX	STD {
 		int linux_sched_get_priority_max(
 		    l_int policy
 		);
 	}
 160	AUE_SCHED_GET_PRIORITY_MIN	STD {
 		int linux_sched_get_priority_min(
 		    l_int policy
 		);
 	}
 161	AUE_SCHED_RR_GET_INTERVAL	STD	{
 		int linux_sched_rr_get_interval(
 		    l_pid_t pid,
 		    struct l_timespec *interval
 		);
 	}
 162	AUE_NULL	STD	{
 		int linux_nanosleep(
 		    const struct l_timespec *rqtp,
 		    struct l_timespec *rmtp
 		);
 	}
 163	AUE_NULL	STD	{
 		int linux_mremap(
 		    l_ulong addr,
 		    l_ulong old_len,
 		    l_ulong new_len,
 		    l_ulong flags,
 		    l_ulong new_addr
 		);
 	}
 164	AUE_SETRESUID	STD	{
 		int linux_setresuid16(
 		    l_uid16_t ruid,
 		    l_uid16_t euid,
 		    l_uid16_t suid);
 	}
 165	AUE_GETRESUID	STD	{
 		int linux_getresuid16(
 		    l_uid16_t *ruid,
 		    l_uid16_t *euid,
 		    l_uid16_t *suid);
 	}
 166	AUE_NULL	UNIMPL  ; was linux_vm86
 167	AUE_NULL	UNIMPL  ; was linux_query_module
-168	AUE_POLL	NOPROTO	{
-		int poll(
+168	AUE_POLL	STD	{
+		int linux_poll(
 		    struct pollfd* fds,
 		    unsigned int nfds,
 		    long timeout
 		);
 	}
 169	AUE_NULL	UNIMPL  ; was linux_nfsservctl
 170	AUE_SETRESGID	STD	{
 		int linux_setresgid16(
 		    l_gid16_t rgid,
 		    l_gid16_t egid,
 		    l_gid16_t sgid);
 	}
 171	AUE_GETRESGID	STD	{
 		int linux_getresgid16(
 		    l_gid16_t *rgid,
 		    l_gid16_t *egid,
 		    l_gid16_t *sgid);
 	}
 172	AUE_PRCTL	STD	{
 		int linux_prctl(
 		    l_int option,
 		    l_int arg2,
 		    l_int arg3,
 		    l_int arg4,
 		    l_int arg5
 		);
 	}
 173	AUE_NULL	STD	{
 		int linux_rt_sigreturn(
 		    struct l_ucontext *ucp
 		);
 	}
 174	AUE_NULL	STD	{
 		int linux_rt_sigaction(
 		    l_int sig,
 		    l_sigaction_t *act,
 		    l_sigaction_t *oact,
 		    l_size_t sigsetsize
 		);
 	}
 175	AUE_NULL	STD	{
 		int linux_rt_sigprocmask(
 		    l_int how,
 		    l_sigset_t *mask,
 		    l_sigset_t *omask,
 		    l_size_t sigsetsize
 		);
 	}
 176	AUE_NULL	STD	{
 		int linux_rt_sigpending(
 		    l_sigset_t *set,
 		    l_size_t sigsetsize
 		);
 	}
 177	AUE_NULL	STD	{
 		int linux_rt_sigtimedwait(
 		    l_sigset_t *mask,
 		    l_siginfo_t *ptr,
 		    struct l_timespec *timeout,
 		    l_size_t sigsetsize
 		);
 	}
 178	AUE_NULL	STD	{
 		int linux_rt_sigqueueinfo(
 		    l_pid_t pid,
 		    l_int sig,
 		    l_siginfo_t *info
 		);
 	}
 179	AUE_NULL	STD	{
 		int linux_rt_sigsuspend(
 		    l_sigset_t *newset,
 		    l_size_t sigsetsize
 		);
 	}
 180	AUE_PREAD	STD	{
 		int linux_pread(
 		    l_uint fd,
 		    char *buf,
 		    l_size_t nbyte,
 		    l_loff_t offset
 		);
 	}
 181	AUE_PWRITE	STD	{
 		int linux_pwrite(
 		    l_uint fd,
 		    char *buf,
 		    l_size_t nbyte,
 		    l_loff_t offset
 		);
 	}
 182	AUE_CHOWN	STD	{
 		int linux_chown16(
 		    char *path,
 		    l_uid16_t uid,
 		    l_gid16_t gid);
 	}
 183	AUE_GETCWD	STD	{
 		int linux_getcwd(
 		    char *buf,
 		    l_ulong bufsize
 		);
 	}
 184	AUE_CAPGET	STD	{
 		int linux_capget(
 		    struct l_user_cap_header *hdrp,
 		    struct l_user_cap_data *datap
 		);
 	}
 185	AUE_CAPSET	STD	{
 		int linux_capset(
 		    struct l_user_cap_header *hdrp,
 		    struct l_user_cap_data *datap
 		);
 	}
 186	AUE_NULL	STD	{
 		int linux_sigaltstack(
 		    l_stack_t *uss,
 		    l_stack_t *uoss
 		);
 	}
 187	AUE_SENDFILE	STD	{
 		int linux_sendfile(
 			l_int out,
 			l_int in,
 			l_long *offset,
 			l_size_t count
 		);
 	}
 188	AUE_NULL	UNIMPL	; was getpmsg
 189	AUE_NULL	UNIMPL	; was putpmsg
 190	AUE_VFORK	STD	{
 		int linux_vfork(void);
 	}
 ; 191: ugetrlimit
 191	AUE_GETRLIMIT	STD	{
 		int linux_getrlimit(
 		    l_uint resource,
 		    struct l_rlimit *rlim
 		);
 	}
 192	AUE_MMAP	STD	{
 		int linux_mmap2(
 		    l_ulong addr,
 		    l_ulong len,
 		    l_ulong prot,
 		    l_ulong flags,
 		    l_ulong fd,
 		    l_ulong pgoff
 		);
 	}
 193	AUE_TRUNCATE	STD	{
 		int linux_truncate64(
 		    char *path,
 		    l_loff_t length
 		);
 	}
 194	AUE_FTRUNCATE	STD	{
 		int linux_ftruncate64(
 		    l_uint fd,
 		    l_loff_t length
 		);
 	}
 195	AUE_STAT	STD	{
 		int linux_stat64(
 		    const char *filename,
 		    struct l_stat64 *statbuf
 		);
 	}
 196	AUE_LSTAT	STD	{
 		int linux_lstat64(
 		    const char *filename,
 		    struct l_stat64 *statbuf
 		);
 	}
 197	AUE_FSTAT	STD	{
 		int linux_fstat64(
 		    l_int fd,
 		    struct l_stat64 *statbuf
 		);
 	}
 198	AUE_LCHOWN	STD	{
 		int linux_lchown(
 		    char *path,
 		    l_uid_t uid,
 		    l_gid_t gid);
 	}
 199	AUE_GETUID	STD	{
 		int linux_getuid(void);
 	}
 200	AUE_GETGID	STD	{
 		int linux_getgid(void);
 	}
 201	AUE_GETEUID	NOPROTO	{
 		int geteuid(void);
 	}
 202	AUE_GETEGID	NOPROTO	{
 		int getegid(void);
 	}
 203	AUE_SETREUID	NOPROTO	{
 		int setreuid(
 		    uid_t ruid,
 		    uid_t euid);
 	}
 204	AUE_SETREGID	NOPROTO	{
 		int setregid(
 		    gid_t rgid,
 		    gid_t egid);
 	}
 205	AUE_GETGROUPS	STD	{
 		int linux_getgroups(
 		    l_int gidsetsize,
 		    l_gid_t *grouplist
 		);
 	}
 206	AUE_SETGROUPS	STD	{
 		int linux_setgroups(
 		    l_int gidsetsize,
 		    l_gid_t *grouplist
 		);
 	}
 207	AUE_FCHOWN	NODEF	fchown fchown fchown_args int
 208	AUE_SETRESUID	NOPROTO	{
 		int setresuid(
 		    uid_t ruid,
 		    uid_t euid,
 		    uid_t suid);
 	}
 209	AUE_GETRESUID	NOPROTO	{
 		int getresuid(
 		    uid_t *ruid,
 		    uid_t *euid,
 		    uid_t *suid);
 	}
 210	AUE_SETRESGID	NOPROTO	{
 		int setresgid(
 		    gid_t rgid,
 		    gid_t egid,
 		    gid_t sgid);
 	}
 211	AUE_GETRESGID	NOPROTO	{
 		int getresgid(
 		    gid_t *rgid,
 		    gid_t *egid,
 		    gid_t *sgid);
 	}
 212	AUE_CHOWN	STD	{
 		int linux_chown(
 		    char *path,
 		    l_uid_t uid,
 		    l_gid_t gid);
 	}
 213	AUE_SETUID	NOPROTO	{
 		int setuid(
 		    uid_t uid);
 	}
 214	AUE_SETGID	NOPROTO	{
 		int setgid(
 		    gid_t gid);
 	}
 215	AUE_SETFSUID	STD	{
 		int linux_setfsuid(
 		    l_uid_t uid);
 	}
 216	AUE_SETFSGID	STD	{
 		int linux_setfsgid(
 		    l_gid_t gid);
 	}
 
 217	AUE_GETDIRENTRIES	STD {
 		int linux_getdents64(
 		    l_uint fd,
 		    void *dirent,
 		    l_uint count
 		);
 	}
 218	AUE_PIVOT_ROOT	STD	{
 		int linux_pivot_root(
 		    char *new_root,
 		    char *put_old);
 	}
 219	AUE_MINCORE	STD	{
 		int linux_mincore(
 		    l_ulong start,
 		    l_size_t len,
 		    u_char *vec
 		);
 	}
 220	AUE_MADVISE	NOPROTO	{
 		int madvise(void *addr,
 		    size_t len,
 		    int behav
 		);
 	}
 221	AUE_FCNTL	STD	{
 		int linux_fcntl64(
 		    l_uint fd,
 		    l_uint cmd,
 		    l_ulong arg
 		);
 	}
 222	AUE_NULL	UNIMPL
 223	AUE_NULL	UNIMPL
 224	AUE_NULL	STD	{
 		long linux_gettid(void);
 	}
 225	AUE_NULL	UNIMPL	linux_readahead
 226	AUE_NULL	STD	{
 		int linux_setxattr(void);
 	}
 227	AUE_NULL	STD	{
 		int linux_lsetxattr(void);
 	}
 228	AUE_NULL	STD	{
 		int linux_fsetxattr(void);
 	}
 229	AUE_NULL	STD	{
 		int linux_getxattr(void);
 	}
 230	AUE_NULL	STD	{
 		int linux_lgetxattr(void);
 	}
 231	AUE_NULL	STD	{
 		int linux_fgetxattr(void);
 	}
 232	AUE_NULL	STD	{
 		int linux_listxattr(void);
 	}
 233	AUE_NULL	STD	{
 		int linux_llistxattr(void);
 	}
 234	AUE_NULL	STD	{
 		int linux_flistxattr(void);
 	}
 235	AUE_NULL	STD	{
 		int linux_removexattr(void);
 	}
 236	AUE_NULL	STD	{
 		int linux_lremovexattr(void);
 	}
 237	AUE_NULL	STD	{
 		int linux_fremovexattr(void);
 	}
 238	AUE_NULL	STD	{
 		int linux_tkill(
 		    int tid,
 		    int sig
 		);
 	}
 239	AUE_SENDFILE	STD	{
 		int linux_sendfile64(
 			l_int out,
 			l_int in,
 			l_loff_t *offset,
 			l_size_t count
 		);
 	}
 240	AUE_NULL	STD	{
 		int linux_sys_futex(
 		    uint32_t *uaddr,
 		    l_int op,
 		    uint32_t val,
 		    struct l_timespec *timeout,
 		    uint32_t *uaddr2,
 		    uint32_t val3
 		);
 	}
 241	AUE_NULL	STD	{
 		int linux_sched_setaffinity(
 		    l_pid_t pid,
 		    l_uint len,
 		    l_ulong *user_mask_ptr
 		);
 	}
 242	AUE_NULL	STD	{
 		int linux_sched_getaffinity(
 		    l_pid_t pid,
 		    l_uint len,
 		    l_ulong *user_mask_ptr
 		);
 	}
 243 	AUE_NULL	UNIMPL	linux_io_setup
 244 	AUE_NULL	UNIMPL	linux_io_destroy
 245	AUE_NULL	UNIMPL	linux_io_getevents
 246	AUE_NULL	UNIMPL	linux_io_submit
 247	AUE_NULL	UNIMPL	linux_io_cancel
 248	AUE_EXIT	STD	{
 		int linux_exit_group(
 		    int error_code
 		);
 	}
 249	AUE_NULL	STD	{
 		int linux_lookup_dcookie(void);
 	}
 250	AUE_NULL	STD	{
 		int linux_epoll_create(
 		    l_int size
 		);
 	}
 251	AUE_NULL	STD	{
 		int linux_epoll_ctl(
 		    l_int epfd,
 		    l_int op,
 		    l_int fd,
 		    struct epoll_event *event
 		);
 	}
 252	AUE_NULL	STD	{
 		int linux_epoll_wait(
 		    l_int epfd,
 		    struct epoll_event *events,
 		    l_int maxevents,
 		    l_int timeout
 		);
 	}
 253	AUE_NULL	STD	{
 		int linux_remap_file_pages(void);
 	}
 
 254	AUE_NULL	UNIMPL	; was set_thread_area
 255	AUE_NULL	UNIMPL	; was get_thread_area
 256	AUE_NULL	STD	{
 		int linux_set_tid_address(
 		    int *tidptr
 		);
 	}
 257	AUE_NULL	STD	{
 		int linux_timer_create(
 		    clockid_t clock_id,
 		    struct sigevent *evp,
 		    l_timer_t *timerid);
 	}
 258	AUE_NULL	STD	{
 		int linux_timer_settime(
 		    l_timer_t timerid,
 		    l_int flags,
 		    const struct itimerspec *new,
 		    struct itimerspec *old);
 	}
 259	AUE_NULL	STD	{
 		int linux_timer_gettime(
 		    l_timer_t timerid,
 		    struct itimerspec *setting
 		);
 	}
 260	AUE_NULL	STD	{
 		int linux_timer_getoverrun(
 		    l_timer_t timerid);
 	}
 261	AUE_NULL	STD	{
 		int linux_timer_delete(
 		    l_timer_t timerid);
 	}
 262	AUE_CLOCK_SETTIME	STD	{
 		int linux_clock_settime(
 		    clockid_t which,
 		    struct l_timespec *tp
 		);
 	}
 263	AUE_NULL	STD	{
 		int linux_clock_gettime(
 		    clockid_t which,
 		    struct l_timespec *tp
 		);
 	}
 264	AUE_NULL	STD	{
 		int linux_clock_getres(
 		    clockid_t which,
 		    struct l_timespec *tp
 		);
 	}
 265	AUE_NULL	STD	{
 		int linux_clock_nanosleep(
 		    clockid_t which,
 		    int flags,
 		    struct l_timespec *rqtp,
 		    struct l_timespec *rmtp
 		);
 	}
 266	AUE_STATFS	STD	{
 		int linux_statfs64(
 		    char *path,
 		    size_t bufsize,
 		    struct l_statfs64_buf *buf
 		);
 	}
 267	AUE_FSTATFS	STD	{
 		int linux_fstatfs64(
 		    l_uint fd,
 		    size_t bufsize,
 		    struct l_statfs64_buf *buf
 		);
 	}
 268	AUE_NULL	STD	{
 		int linux_tgkill(
 		    int tgid,
 		    int pid,
 		    int sig
 		);
 	}
 269	AUE_UTIMES	STD	{
 		int linux_utimes(
 		    char *fname,
 		    struct l_timeval *tptr
 		);
 	}
 270	AUE_NULL	STD	{
 		int linux_fadvise64_64(
 		    int fd,
 		    l_loff_t offset,
 		    l_loff_t len,
 		    int advice
 		);
 	}
 271	AUE_NULL	UNIMPL	pciconfig_iobase
 272	AUE_NULL	UNIMPL	pciconfig_read
 273	AUE_NULL	UNIMPL	pciconfig_write
 ; linux 2.6.6:
 274	AUE_NULL	STD	{
 		int linux_mq_open(
 		    const char *name,
 		    int oflag,
 		    mode_t mode,
 		    struct mq_attr *attr
 		);
 	}
 275	AUE_NULL	STD	{
 		int linux_mq_unlink(
 		    const char *name
 		);
 	}
 276	AUE_NULL	STD	{
 		int linux_mq_timedsend(
 		    l_mqd_t mqd,
 		    const char *msg_ptr,
 		    size_t msg_len,
 		    unsigned int msg_prio,
 		    const struct l_timespec *abs_timeout
 		);
 	}
 277	AUE_NULL	STD	{
 		int linux_mq_timedreceive(
 		    l_mqd_t mqd,
 		    char *msg_ptr,
 		    size_t msg_len,
 		    unsigned int msg_prio,
 		    const struct l_timespec *abs_timeout
 		);
 	}
 278	AUE_NULL	STD	{
 		int linux_mq_notify(
 		    l_mqd_t mqd,
 		    const struct l_timespec *abs_timeout
 		);
 	}
 279	AUE_NULL	STD	{
 		int linux_mq_getsetattr(
 		    l_mqd_t mqd,
 		    const struct mq_attr *attr,
 		    struct mq_attr *oattr
 		);
 	}
 280	AUE_WAIT6	STD	{
 		int linux_waitid(
 		    int idtype,
 		    l_pid_t id,
 		    l_siginfo_t *info,
 		    int options,
 		    void *rusage
 		);
 	}
 281	AUE_SOCKET	STD	{
 		int linux_socket(
 		    l_int domain,
 		    l_int type,
 		    l_int protocol
 		);
 	}
 282	AUE_BIND	STD	{
 		int linux_bind(
 		    l_int s,
 		    l_uintptr_t name,
 		    l_int namelen
 		);
 	}
 283	AUE_CONNECT	STD	{
 		int linux_connect(
 		    l_int s,
 		    l_uintptr_t name,
 		    l_int namelen
 		);
 	}
 284	AUE_LISTEN	STD	{
 		int linux_listen(
 		    l_int s,
 		    l_int backlog
 		);
 	}
 285	AUE_ACCEPT	STD	{
 		int linux_accept(
 		    l_int s,
 		    l_uintptr_t addr,
 		    l_uintptr_t namelen
 		);
 	}
 286	AUE_GETSOCKNAME	STD	{
 		int linux_getsockname(
 		    l_int s,
 		    l_uintptr_t addr,
 		    l_uintptr_t namelen
 		);
 	}
 287	AUE_GETPEERNAME	STD	{
 		int linux_getpeername(
 		    l_int s,
 		    l_uintptr_t addr,
 		    l_uintptr_t namelen
 		);
 	}
 288	AUE_SOCKETPAIR	STD	{
 		int linux_socketpair(
 		    l_int domain,
 		    l_int type,
 		    l_int protocol,
 		    l_uintptr_t rsv
 		);
 	}
 289	AUE_SEND	STD	{
 		int linux_send(
 		    int s,
 		    l_uintptr_t msg,
 		    int len,
 		    int flags
 		);
 	}
 290	AUE_SENDTO	STD	{
 		int linux_sendto(
 		    l_int s,
 		    l_uintptr_t msg,
 		    l_int len,
 		    l_int flags,
 		    l_uintptr_t to,
 		    l_int tolen
 		);
 	}
 291	AUE_RECV	STD	{
 		int linux_recv(
 		    int s,
 		    l_uintptr_t msg,
 		    int len,
 		    int flags
 		);
 	}
 292	AUE_RECVFROM	STD	{
 		int linux_recvfrom(
 		    l_int s,
 		    l_uintptr_t buf,
 		    l_size_t len,
 		    l_int flags,
 		    l_uintptr_t from,
 		    l_uintptr_t fromlen
 		);
 	}
 293	AUE_NULL	STD	{
 		int linux_shutdown(
 		    l_int s,
 		    l_int how
 		);
 	}
 294	AUE_SETSOCKOPT	STD	{
 		int linux_setsockopt(
 		    l_int s,
 		    l_int level,
 		    l_int optname,
 		    l_uintptr_t optval,
 		    l_int optlen
 		);
 	}
 295	AUE_GETSOCKOPT	STD	{
 		int linux_getsockopt(
 		    l_int s,
 		    l_int level,
 		    l_int optname,
 		    l_uintptr_t optval,
 		    l_uintptr_t optlen
 		);
 	}
 296	AUE_SENDMSG	STD	{
 		int linux_sendmsg(
 		    l_int s,
 		    l_uintptr_t msg,
 		    l_int flags
 		);
 	}
 297	AUE_RECVMSG	STD	{
 		int linux_recvmsg(
 		    l_int s,
 		    l_uintptr_t msg,
 		    l_int flags
 		);
 	}
 298	AUE_NULL	STD	{
 		int linux_semop(
 		    l_int semid,
 		    struct l_sembuf *tsops,
 		    l_uint nsops
 		);
 	}
 299	AUE_NULL	STD	{
 		int linux_semget(l_key_t key,
 		    l_int nsems,
 		    l_int semflg
 		);
 	}
 300	AUE_NULL	STD	{
 		int linux_semctl(
 		    l_int semid,
 		    l_int semnum,
 		    l_int cmd,
 		    union l_semun arg
 		);
 	}
 301	AUE_NULL	STD	{
 		int linux_msgsnd(
 		    l_int msqid,
 		    struct l_msgbuf *msgp,
 		    l_size_t msgsz,
 		    l_int msgflg
 		);
 	}
 302	AUE_NULL	STD	{
 		int linux_msgrcv(
 		    l_int msqid,
 		    struct l_msgbuf *msgp,
 		    l_size_t msgsz,
 		    l_long msgtyp,
 		    l_int msgflg
 		);
 	}
 303	AUE_NULL	STD	{
 		int linux_msgget(
 		    l_key_t key,
 		    l_int msgflg
 		);
 	}
 304	AUE_NULL	STD	{
 		int linux_msgctl(
 		    l_int msqid,
 		    l_int cmd,
 		    struct l_msqid_ds *buf
 		);
 	}
 305	AUE_NULL	STD	{
 		int linux_shmat(
 		    l_int shmid,
 		    char *shmaddr,
 		    l_int shmflg
 		);
 	}
 306	AUE_NULL	STD	{
 		int linux_shmdt(
 		    char *shmaddr
 		);
 	}
 307	AUE_NULL	STD	{
 		int linux_shmget(
 		    l_key_t key,
 		    l_size_t size,
 		    l_int shmflg
 		);
 	}
 308	AUE_NULL	STD	{
 		int linux_shmctl(
 		    l_int shmid,
 		    l_int cmd,
 		    struct l_shmid_ds *buf
 		);
 	}
 ; linux 2.6.11:
 309	AUE_NULL	STD	{
 		int linux_add_key(void);
 	}
 310	AUE_NULL	STD	{
 		int linux_request_key(void);
 	}
 311	AUE_NULL	STD	{
 		int linux_keyctl(void);
 	}
 312	AUE_NULL	UNIMPL	semtimedop
 313	AUE_NULL	UNIMPL	; was vserver
 
 ; linux 2.6.13:
 314	AUE_NULL	STD	{
 		int linux_ioprio_set(void);
 	}
 315	AUE_NULL	STD	{
 		int linux_ioprio_get(void);
 	}
 316	AUE_NULL	STD	{
 		int linux_inotify_init(void);
 	}
 317	AUE_NULL	STD	{
 		int linux_inotify_add_watch(void);
 	}
 318	AUE_NULL	STD	{
 		int linux_inotify_rm_watch(void);
 	}
 
 319	AUE_NULL	STD	{
 		int linux_mbind(void);
 	}
 320	AUE_NULL	STD	{
 		int linux_get_mempolicy(void);
 	}
 321	AUE_NULL	STD	{
 		int linux_set_mempolicy(void);
 	}
 
 ; linux 2.6.16:
 322	AUE_OPEN_RWTC	STD	{
 		int linux_openat(
 		    l_int dfd,
 		    const char *filename,
 		    l_int flags,
 		    l_int mode
 		);
 	}
 323	AUE_MKDIRAT	STD	{
 		int linux_mkdirat(
 		    l_int dfd,
 		    const char *pathname,
 		    l_int mode
 		);
 	}
 324	AUE_MKNODAT	STD	{
 		int linux_mknodat(
 		    l_int dfd,
 		    const char *filename,
 		    l_int mode,
 		    l_uint dev
 		);
 	}
 325	AUE_FCHOWNAT	STD	{
 		int linux_fchownat(
 		    l_int dfd,
 		    const char *filename,
 		    l_uid16_t uid,
 		    l_gid16_t gid,
 		    l_int flag
 		);
 	}
 326	AUE_FUTIMESAT	STD	{
 		int linux_futimesat(
 		    l_int dfd,
 		    char *filename,
 		    struct l_timeval *utimes
 		);
 	}
 327	AUE_FSTATAT	STD	{
 		int linux_fstatat64(
 		    l_int dfd,
 		    char *pathname,
 		    struct l_stat64 *statbuf,
 		    l_int flag
 		);
 	}
 328	AUE_UNLINKAT	STD	{
 		int linux_unlinkat(
 		    l_int dfd,
 		    const char *pathname,
 		    l_int flag
 		);
 	}
 329	AUE_RENAMEAT	STD	{
 		int linux_renameat(
 		    l_int olddfd,
 		    const char *oldname,
 		    l_int newdfd,
 		    const char *newname
 		);
 	}
 330	AUE_LINKAT	STD	{
 		int linux_linkat(
 		    l_int olddfd,
 		    const char *oldname,
 		    l_int newdfd,
 		    const char *newname,
 		    l_int flag
 		);
 	}
 331	AUE_SYMLINKAT	STD	{
 		int linux_symlinkat(
 		    const char *oldname,
 		    l_int newdfd,
 		    const char *newname
 		);
 	}
 332	AUE_READLINKAT	STD	{
 		int linux_readlinkat(
 		    l_int dfd,
 		    const char *path,
 		    char *buf,
 		    l_int bufsiz
 		);
 	}
 333	AUE_FCHMODAT	STD	{
 		int linux_fchmodat(
 		    l_int dfd,
 		    const char *filename,
 		    l_mode_t mode
 		);
 	}
 334	AUE_FACCESSAT	STD	{
 		int linux_faccessat(
 		    l_int dfd,
 		    const char *filename,
 		    l_int amode
 		);
 	}
 335	AUE_SELECT	STD	{
 		int linux_pselect6(
 		    l_int nfds,
 		    l_fd_set *readfds,
 		    l_fd_set *writefds,
 		    l_fd_set *exceptfds,
 		    struct l_timespec *tsp,
 		    l_uintptr_t *sig
 		);
 	}
 336	AUE_POLL	STD	{
 		int linux_ppoll(
 		    struct pollfd *fds,
 		    uint32_t nfds,
 		    struct l_timespec *tsp,
 		    l_sigset_t *sset,
 		    l_size_t ssize
 		);
 	}
 337	AUE_NULL	STD	{
 		int linux_unshare(void);
 	}
 ; linux 2.6.17:
 338	AUE_NULL	STD	{
 		int linux_set_robust_list(
 		    struct linux_robust_list_head *head,
 		    l_size_t len
 		);
 	}
 339	AUE_NULL	STD	{
 		int linux_get_robust_list(
 		    l_int pid,
 		    struct linux_robust_list_head **head,
 		    l_size_t *len
 		);
 	}
 340	AUE_NULL	STD	{
 		int linux_splice(void);
 	}
 341	AUE_NULL	STD	{
 		int linux_sync_file_range(
 		    l_int fd,
 		    l_loff_t offset,
 		    l_loff_t nbytes,
 		    unsigned int flags
 		);
 	}
 342	AUE_NULL	STD	{
 		int linux_tee(void);
 	}
 343	AUE_NULL	STD	{
 		int linux_vmsplice(void);
 	}
 ; linux 2.6.18:
 344	AUE_NULL	STD	{
 		int linux_move_pages(void);
 	}
 ; linux 2.6.19:
 345	AUE_NULL	STD	{
 		int linux_getcpu(
 		    l_uint *cpu,
 		    l_uint *node,
 		    void *cache
 		);
 	}
 346	AUE_NULL	STD	{
 		int linux_epoll_pwait(
 		    l_int epfd,
 		    struct epoll_event *events,
 		    l_int maxevents,
 		    l_int timeout,
 		    l_sigset_t *mask
 		);
 	}
 ; linux 2.6.22:
 347	AUE_NULL	STD	{
 		int linux_kexec_load(void);
 	}
 348	AUE_FUTIMESAT	STD	{
 		int linux_utimensat(
 		    l_int dfd,
 		    const char *pathname,
 		    const struct l_timespec *times,
 		    l_int flags
 		);
 	}
 349	AUE_NULL	STD	{
 		int linux_signalfd(void);
 	}
 350	AUE_NULL	STD	{
 		int linux_timerfd_create(void);
 	}
 351	AUE_NULL	STD	{
 		int linux_eventfd(
 		    l_uint initval
 		);
 	}
 ; linux 2.6.23:
 352	AUE_NULL	STD	{
 		int linux_fallocate(
 		    l_int fd,
 		    l_int mode,
 		    l_loff_t offset,
 		    l_loff_t len
 		);
 	}
 ; linux 2.6.25:
 353	AUE_NULL	STD	{
 		int linux_timerfd_settime(void);
 	}
 354	AUE_NULL	STD	{
 		int linux_timerfd_gettime(void);
 	}
 ; linux 2.6.27:
 355	AUE_NULL	STD	{
 		int linux_signalfd4(void);
 	}
 356	AUE_NULL	STD	{
 		int linux_eventfd2(
 		    l_uint initval,
 		    l_int flags
 		);
 	}
 357	AUE_NULL	STD	{
 		int linux_epoll_create1(
 		    l_int flags
 		);
 	}
 358	AUE_NULL	STD	{
 		int linux_dup3(
 		    l_int oldfd,
 		    l_int newfd,
 		    l_int flags
 		);
 	}
 359	AUE_NULL	STD	{
 		int linux_pipe2(
 		    l_int *pipefds,
 		    l_int flags
 		);
 	}
 360	AUE_NULL	STD	{
 		int linux_inotify_init1(void);
 	}
 ; linux 2.6.30:
 361	AUE_NULL	STD	{
 		int linux_preadv(void);
 	}
 362	AUE_NULL	STD	{
 		int linux_pwritev(void);
 	}
 ; linux 2.6.31:
 363	AUE_NULL	STD	{
 		int linux_rt_tsigqueueinfo(void);
 	}
 364	AUE_NULL	STD	{
 		int linux_perf_event_open(void);
 	}
 ; linux 2.6.33:
 365	AUE_NULL	STD	{
 		int linux_recvmmsg(
 		    l_int s,
 		    struct l_mmsghdr *msg,
 		    l_uint vlen,
 		    l_uint flags,
 		    struct l_timespec *timeout
 		);
 	}
 366	AUE_ACCEPT	STD	{
 		int linux_accept4(
 		    l_int s,
 		    l_uintptr_t addr,
 		    l_uintptr_t namelen,
 		    int flags
 		);
 	}
 367	AUE_NULL	STD	{
 		int linux_fanotify_init(void);
 	}
 368	AUE_NULL	STD	{
 		int linux_fanotify_mark(void);
 	}
 ; linux 2.6.36:
 369	AUE_NULL	STD	{
 		int linux_prlimit64(
 		    l_pid_t pid,
 		    l_uint resource,
 		    struct rlimit *new,
 		    struct rlimit *old);
 	}
 ; later:
 370	AUE_NULL	STD	{
 		int linux_name_to_handle_at(void);
 	}
 371	AUE_NULL	STD	{
 		int linux_open_by_handle_at(void);
 	}
 372	AUE_NULL	STD	{
 		int linux_clock_adjtime(void);
 	}
 373	AUE_SYNC	STD	{
 		int linux_syncfs(
 		    l_int fd);
 	}
 374	AUE_NULL	STD	{
 		int linux_sendmmsg(
 		    l_int s,
 		    struct l_mmsghdr *msg,
 		    l_uint vlen,
 		    l_uint flags
 		);
 	}
 375	AUE_NULL	STD	{
 		int linux_setns(void);
 	}
 376	AUE_NULL	STD	{
 		int linux_process_vm_readv(void);
 	}
 377	AUE_NULL	STD	{
 		int linux_process_vm_writev(void);
 	}
 378	AUE_NULL	UNIMPL	kcmp
 379	AUE_NULL	UNIMPL	finit_module
 
 380	AUE_NULL	UNIMPL	sys_sched_setattr
 381	AUE_NULL	UNIMPL	sys_sched_getattr
 382	AUE_NULL	UNIMPL	sys_renameat2
 383	AUE_NULL	UNIMPL	sys_seccomp
 384	AUE_NULL	UNIMPL	sys_getrandom
 385	AUE_NULL	UNIMPL	sys_memfd_create
 386	AUE_NULL	UNIMPL	sys_bpf
 387	AUE_NULL	UNIMPL	sys_execveat
 388	AUE_NULL	UNIMPL	sys_userfaultfd
 389	AUE_NULL	UNIMPL	sys_membarrier
 390	AUE_NULL	UNIMPL	sys_mlock2
 391	AUE_NULL	UNIMPL	sys_copy_file_range
 392	AUE_NULL	UNIMPL	sys_preadv2
 393	AUE_NULL	UNIMPL	sys_pwritev2
 394	AUE_NULL	UNIMPL
 395	AUE_NULL	UNIMPL
 396	AUE_NULL	UNIMPL
 397	AUE_NULL	UNIMPL
 398	AUE_NULL	UNIMPL
 399	AUE_NULL	UNIMPL
 
 ; ARM specific
 ; Effective number here is 0x000f0000
 ; but we must not breaks syscall numbering
 
 400	AUE_NULL	UNIMPL  unimpl400
 401	AUE_NULL	UNIMPL	breakpoint
 402	AUE_NULL	UNIMPL	cacheflush
 403	AUE_NULL	UNIMPL	usr26
 404	AUE_NULL	UNIMPL	usr32
 405	AUE_NULL	STD	{
 		int linux_set_tls(
 		    void* tls
 		);
 	}
 
 ; please, keep this line at the end.
 406	AUE_NULL	UNIMPL	nosys
diff --git a/sys/compat/linux/linux_misc.c b/sys/compat/linux/linux_misc.c
index 80458364017f..1c1a8952bd79 100644
--- a/sys/compat/linux/linux_misc.c
+++ b/sys/compat/linux/linux_misc.c
@@ -1,2860 +1,2880 @@
 /*-
  * SPDX-License-Identifier: BSD-3-Clause
  *
  * Copyright (c) 2002 Doug Rabson
  * Copyright (c) 1994-1995 Søren Schmidt
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer
  *    in this position and unchanged.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. The name of the author may not be used to endorse or promote products
  *    derived from this software without specific prior written permission
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 #include "opt_compat.h"
 
 #include <sys/param.h>
 #include <sys/blist.h>
 #include <sys/fcntl.h>
 #if defined(__i386__)
 #include <sys/imgact_aout.h>
 #endif
 #include <sys/jail.h>
 #include <sys/kernel.h>
 #include <sys/limits.h>
 #include <sys/lock.h>
 #include <sys/malloc.h>
 #include <sys/mman.h>
 #include <sys/mount.h>
 #include <sys/msgbuf.h>
 #include <sys/mutex.h>
 #include <sys/namei.h>
 #include <sys/poll.h>
 #include <sys/priv.h>
 #include <sys/proc.h>
 #include <sys/procctl.h>
 #include <sys/reboot.h>
 #include <sys/racct.h>
 #include <sys/random.h>
 #include <sys/resourcevar.h>
 #include <sys/sched.h>
 #include <sys/sdt.h>
 #include <sys/signalvar.h>
 #include <sys/stat.h>
 #include <sys/syscallsubr.h>
 #include <sys/sysctl.h>
 #include <sys/sysproto.h>
 #include <sys/systm.h>
 #include <sys/time.h>
 #include <sys/vmmeter.h>
 #include <sys/vnode.h>
 #include <sys/wait.h>
 #include <sys/cpuset.h>
 #include <sys/uio.h>
 
 #include <security/mac/mac_framework.h>
 
 #include <vm/vm.h>
 #include <vm/pmap.h>
 #include <vm/vm_kern.h>
 #include <vm/vm_map.h>
 #include <vm/vm_extern.h>
 #include <vm/swap_pager.h>
 
 #ifdef COMPAT_LINUX32
 #include <machine/../linux32/linux.h>
 #include <machine/../linux32/linux32_proto.h>
 #else
 #include <machine/../linux/linux.h>
 #include <machine/../linux/linux_proto.h>
 #endif
 
 #include <compat/linux/linux_common.h>
 #include <compat/linux/linux_dtrace.h>
 #include <compat/linux/linux_file.h>
 #include <compat/linux/linux_mib.h>
 #include <compat/linux/linux_signal.h>
 #include <compat/linux/linux_timer.h>
 #include <compat/linux/linux_util.h>
 #include <compat/linux/linux_sysproto.h>
 #include <compat/linux/linux_emul.h>
 #include <compat/linux/linux_misc.h>
 
 int stclohz;				/* Statistics clock frequency */
 
 static unsigned int linux_to_bsd_resource[LINUX_RLIM_NLIMITS] = {
 	RLIMIT_CPU, RLIMIT_FSIZE, RLIMIT_DATA, RLIMIT_STACK,
 	RLIMIT_CORE, RLIMIT_RSS, RLIMIT_NPROC, RLIMIT_NOFILE,
 	RLIMIT_MEMLOCK, RLIMIT_AS
 };
 
 struct l_sysinfo {
 	l_long		uptime;		/* Seconds since boot */
 	l_ulong		loads[3];	/* 1, 5, and 15 minute load averages */
 #define LINUX_SYSINFO_LOADS_SCALE 65536
 	l_ulong		totalram;	/* Total usable main memory size */
 	l_ulong		freeram;	/* Available memory size */
 	l_ulong		sharedram;	/* Amount of shared memory */
 	l_ulong		bufferram;	/* Memory used by buffers */
 	l_ulong		totalswap;	/* Total swap space size */
 	l_ulong		freeswap;	/* swap space still available */
 	l_ushort	procs;		/* Number of current processes */
 	l_ushort	pads;
 	l_ulong		totalhigh;
 	l_ulong		freehigh;
 	l_uint		mem_unit;
 	char		_f[20-2*sizeof(l_long)-sizeof(l_int)];	/* padding */
 };
 
 struct l_pselect6arg {
 	l_uintptr_t	ss;
 	l_size_t	ss_len;
 };
 
 static int	linux_utimensat_lts_to_ts(struct l_timespec *,
 			struct timespec *);
 #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
 static int	linux_utimensat_lts64_to_ts(struct l_timespec64 *,
 			struct timespec *);
 #endif
 static int	linux_common_utimensat(struct thread *, int,
 			const char *, struct timespec *, int);
 static int	linux_common_pselect6(struct thread *, l_int,
 			l_fd_set *, l_fd_set *, l_fd_set *,
 			struct timespec *, l_uintptr_t *);
 static int	linux_common_ppoll(struct thread *, struct pollfd *,
 			uint32_t, struct timespec *, l_sigset_t *,
 			l_size_t);
 static int	linux_pollin(struct thread *, struct pollfd *,
 			struct pollfd *, u_int);
 static int	linux_pollout(struct thread *, struct pollfd *,
 			struct pollfd *, u_int);
 
 int
 linux_sysinfo(struct thread *td, struct linux_sysinfo_args *args)
 {
 	struct l_sysinfo sysinfo;
 	int i, j;
 	struct timespec ts;
 
 	bzero(&sysinfo, sizeof(sysinfo));
 	getnanouptime(&ts);
 	if (ts.tv_nsec != 0)
 		ts.tv_sec++;
 	sysinfo.uptime = ts.tv_sec;
 
 	/* Use the information from the mib to get our load averages */
 	for (i = 0; i < 3; i++)
 		sysinfo.loads[i] = averunnable.ldavg[i] *
 		    LINUX_SYSINFO_LOADS_SCALE / averunnable.fscale;
 
 	sysinfo.totalram = physmem * PAGE_SIZE;
 	sysinfo.freeram = (u_long)vm_free_count() * PAGE_SIZE;
 
 	/*
 	 * sharedram counts pages allocated to named, swap-backed objects such
 	 * as shared memory segments and tmpfs files.  There is no cheap way to
 	 * compute this, so just leave the field unpopulated.  Linux itself only
 	 * started setting this field in the 3.x timeframe.
 	 */
 	sysinfo.sharedram = 0;
 	sysinfo.bufferram = 0;
 
 	swap_pager_status(&i, &j);
 	sysinfo.totalswap = i * PAGE_SIZE;
 	sysinfo.freeswap = (i - j) * PAGE_SIZE;
 
 	sysinfo.procs = nprocs;
 
 	/*
 	 * Platforms supported by the emulation layer do not have a notion of
 	 * high memory.
 	 */
 	sysinfo.totalhigh = 0;
 	sysinfo.freehigh = 0;
 
 	sysinfo.mem_unit = 1;
 
 	return (copyout(&sysinfo, args->info, sizeof(sysinfo)));
 }
 
 #ifdef LINUX_LEGACY_SYSCALLS
 int
 linux_alarm(struct thread *td, struct linux_alarm_args *args)
 {
 	struct itimerval it, old_it;
 	u_int secs;
 	int error;
 
 	secs = args->secs;
 	/*
 	 * Linux alarm() is always successful. Limit secs to INT32_MAX / 2
 	 * to match kern_setitimer()'s limit to avoid error from it.
 	 *
 	 * XXX. Linux limit secs to INT_MAX on 32 and does not limit on 64-bit
 	 * platforms.
 	 */
 	if (secs > INT32_MAX / 2)
 		secs = INT32_MAX / 2;
 
 	it.it_value.tv_sec = secs;
 	it.it_value.tv_usec = 0;
 	timevalclear(&it.it_interval);
 	error = kern_setitimer(td, ITIMER_REAL, &it, &old_it);
 	KASSERT(error == 0, ("kern_setitimer returns %d", error));
 
 	if ((old_it.it_value.tv_sec == 0 && old_it.it_value.tv_usec > 0) ||
 	    old_it.it_value.tv_usec >= 500000)
 		old_it.it_value.tv_sec++;
 	td->td_retval[0] = old_it.it_value.tv_sec;
 	return (0);
 }
 #endif
 
 int
 linux_brk(struct thread *td, struct linux_brk_args *args)
 {
 	struct vmspace *vm = td->td_proc->p_vmspace;
 	uintptr_t new, old;
 
 	old = (uintptr_t)vm->vm_daddr + ctob(vm->vm_dsize);
 	new = (uintptr_t)args->dsend;
 	if ((caddr_t)new > vm->vm_daddr && !kern_break(td, &new))
 		td->td_retval[0] = (register_t)new;
 	else
 		td->td_retval[0] = (register_t)old;
 
 	return (0);
 }
 
 #if defined(__i386__)
 /* XXX: what about amd64/linux32? */
 
 int
 linux_uselib(struct thread *td, struct linux_uselib_args *args)
 {
 	struct nameidata ni;
 	struct vnode *vp;
 	struct exec *a_out;
 	vm_map_t map;
 	vm_map_entry_t entry;
 	struct vattr attr;
 	vm_offset_t vmaddr;
 	unsigned long file_offset;
 	unsigned long bss_size;
 	char *library;
 	ssize_t aresid;
 	int error;
 	bool locked, opened, textset;
 
 	a_out = NULL;
 	vp = NULL;
 	locked = false;
 	textset = false;
 	opened = false;
 
 	if (!LUSECONVPATH(td)) {
 		NDINIT(&ni, LOOKUP, ISOPEN | FOLLOW | LOCKLEAF | AUDITVNODE1,
 		    UIO_USERSPACE, args->library, td);
 		error = namei(&ni);
 	} else {
 		LCONVPATHEXIST(td, args->library, &library);
 		NDINIT(&ni, LOOKUP, ISOPEN | FOLLOW | LOCKLEAF | AUDITVNODE1,
 		    UIO_SYSSPACE, library, td);
 		error = namei(&ni);
 		LFREEPATH(library);
 	}
 	if (error)
 		goto cleanup;
 
 	vp = ni.ni_vp;
 	NDFREE(&ni, NDF_ONLY_PNBUF);
 
 	/*
 	 * From here on down, we have a locked vnode that must be unlocked.
 	 * XXX: The code below largely duplicates exec_check_permissions().
 	 */
 	locked = true;
 
 	/* Executable? */
 	error = VOP_GETATTR(vp, &attr, td->td_ucred);
 	if (error)
 		goto cleanup;
 
 	if ((vp->v_mount->mnt_flag & MNT_NOEXEC) ||
 	    ((attr.va_mode & 0111) == 0) || (attr.va_type != VREG)) {
 		/* EACCESS is what exec(2) returns. */
 		error = ENOEXEC;
 		goto cleanup;
 	}
 
 	/* Sensible size? */
 	if (attr.va_size == 0) {
 		error = ENOEXEC;
 		goto cleanup;
 	}
 
 	/* Can we access it? */
 	error = VOP_ACCESS(vp, VEXEC, td->td_ucred, td);
 	if (error)
 		goto cleanup;
 
 	/*
 	 * XXX: This should use vn_open() so that it is properly authorized,
 	 * and to reduce code redundancy all over the place here.
 	 * XXX: Not really, it duplicates far more of exec_check_permissions()
 	 * than vn_open().
 	 */
 #ifdef MAC
 	error = mac_vnode_check_open(td->td_ucred, vp, VREAD);
 	if (error)
 		goto cleanup;
 #endif
 	error = VOP_OPEN(vp, FREAD, td->td_ucred, td, NULL);
 	if (error)
 		goto cleanup;
 	opened = true;
 
 	/* Pull in executable header into exec_map */
 	error = vm_mmap(exec_map, (vm_offset_t *)&a_out, PAGE_SIZE,
 	    VM_PROT_READ, VM_PROT_READ, 0, OBJT_VNODE, vp, 0);
 	if (error)
 		goto cleanup;
 
 	/* Is it a Linux binary ? */
 	if (((a_out->a_magic >> 16) & 0xff) != 0x64) {
 		error = ENOEXEC;
 		goto cleanup;
 	}
 
 	/*
 	 * While we are here, we should REALLY do some more checks
 	 */
 
 	/* Set file/virtual offset based on a.out variant. */
 	switch ((int)(a_out->a_magic & 0xffff)) {
 	case 0413:			/* ZMAGIC */
 		file_offset = 1024;
 		break;
 	case 0314:			/* QMAGIC */
 		file_offset = 0;
 		break;
 	default:
 		error = ENOEXEC;
 		goto cleanup;
 	}
 
 	bss_size = round_page(a_out->a_bss);
 
 	/* Check various fields in header for validity/bounds. */
 	if (a_out->a_text & PAGE_MASK || a_out->a_data & PAGE_MASK) {
 		error = ENOEXEC;
 		goto cleanup;
 	}
 
 	/* text + data can't exceed file size */
 	if (a_out->a_data + a_out->a_text > attr.va_size) {
 		error = EFAULT;
 		goto cleanup;
 	}
 
 	/*
 	 * text/data/bss must not exceed limits
 	 * XXX - this is not complete. it should check current usage PLUS
 	 * the resources needed by this library.
 	 */
 	PROC_LOCK(td->td_proc);
 	if (a_out->a_text > maxtsiz ||
 	    a_out->a_data + bss_size > lim_cur_proc(td->td_proc, RLIMIT_DATA) ||
 	    racct_set(td->td_proc, RACCT_DATA, a_out->a_data +
 	    bss_size) != 0) {
 		PROC_UNLOCK(td->td_proc);
 		error = ENOMEM;
 		goto cleanup;
 	}
 	PROC_UNLOCK(td->td_proc);
 
 	/*
 	 * Prevent more writers.
 	 */
 	error = VOP_SET_TEXT(vp);
 	if (error != 0)
 		goto cleanup;
 	textset = true;
 
 	/*
 	 * Lock no longer needed
 	 */
 	locked = false;
 	VOP_UNLOCK(vp);
 
 	/*
 	 * Check if file_offset page aligned. Currently we cannot handle
 	 * misalinged file offsets, and so we read in the entire image
 	 * (what a waste).
 	 */
 	if (file_offset & PAGE_MASK) {
 		/* Map text+data read/write/execute */
 
 		/* a_entry is the load address and is page aligned */
 		vmaddr = trunc_page(a_out->a_entry);
 
 		/* get anon user mapping, read+write+execute */
 		error = vm_map_find(&td->td_proc->p_vmspace->vm_map, NULL, 0,
 		    &vmaddr, a_out->a_text + a_out->a_data, 0, VMFS_NO_SPACE,
 		    VM_PROT_ALL, VM_PROT_ALL, 0);
 		if (error)
 			goto cleanup;
 
 		error = vn_rdwr(UIO_READ, vp, (void *)vmaddr, file_offset,
 		    a_out->a_text + a_out->a_data, UIO_USERSPACE, 0,
 		    td->td_ucred, NOCRED, &aresid, td);
 		if (error != 0)
 			goto cleanup;
 		if (aresid != 0) {
 			error = ENOEXEC;
 			goto cleanup;
 		}
 	} else {
 		/*
 		 * for QMAGIC, a_entry is 20 bytes beyond the load address
 		 * to skip the executable header
 		 */
 		vmaddr = trunc_page(a_out->a_entry);
 
 		/*
 		 * Map it all into the process's space as a single
 		 * copy-on-write "data" segment.
 		 */
 		map = &td->td_proc->p_vmspace->vm_map;
 		error = vm_mmap(map, &vmaddr,
 		    a_out->a_text + a_out->a_data, VM_PROT_ALL, VM_PROT_ALL,
 		    MAP_PRIVATE | MAP_FIXED, OBJT_VNODE, vp, file_offset);
 		if (error)
 			goto cleanup;
 		vm_map_lock(map);
 		if (!vm_map_lookup_entry(map, vmaddr, &entry)) {
 			vm_map_unlock(map);
 			error = EDOOFUS;
 			goto cleanup;
 		}
 		entry->eflags |= MAP_ENTRY_VN_EXEC;
 		vm_map_unlock(map);
 		textset = false;
 	}
 
 	if (bss_size != 0) {
 		/* Calculate BSS start address */
 		vmaddr = trunc_page(a_out->a_entry) + a_out->a_text +
 		    a_out->a_data;
 
 		/* allocate some 'anon' space */
 		error = vm_map_find(&td->td_proc->p_vmspace->vm_map, NULL, 0,
 		    &vmaddr, bss_size, 0, VMFS_NO_SPACE, VM_PROT_ALL,
 		    VM_PROT_ALL, 0);
 		if (error)
 			goto cleanup;
 	}
 
 cleanup:
 	if (opened) {
 		if (locked)
 			VOP_UNLOCK(vp);
 		locked = false;
 		VOP_CLOSE(vp, FREAD, td->td_ucred, td);
 	}
 	if (textset) {
 		if (!locked) {
 			locked = true;
 			VOP_LOCK(vp, LK_SHARED | LK_RETRY);
 		}
 		VOP_UNSET_TEXT_CHECKED(vp);
 	}
 	if (locked)
 		VOP_UNLOCK(vp);
 
 	/* Release the temporary mapping. */
 	if (a_out)
 		kmap_free_wakeup(exec_map, (vm_offset_t)a_out, PAGE_SIZE);
 
 	return (error);
 }
 
 #endif	/* __i386__ */
 
 #ifdef LINUX_LEGACY_SYSCALLS
 int
 linux_select(struct thread *td, struct linux_select_args *args)
 {
 	l_timeval ltv;
 	struct timeval tv0, tv1, utv, *tvp;
 	int error;
 
 	/*
 	 * Store current time for computation of the amount of
 	 * time left.
 	 */
 	if (args->timeout) {
 		if ((error = copyin(args->timeout, &ltv, sizeof(ltv))))
 			goto select_out;
 		utv.tv_sec = ltv.tv_sec;
 		utv.tv_usec = ltv.tv_usec;
 
 		if (itimerfix(&utv)) {
 			/*
 			 * The timeval was invalid.  Convert it to something
 			 * valid that will act as it does under Linux.
 			 */
 			utv.tv_sec += utv.tv_usec / 1000000;
 			utv.tv_usec %= 1000000;
 			if (utv.tv_usec < 0) {
 				utv.tv_sec -= 1;
 				utv.tv_usec += 1000000;
 			}
 			if (utv.tv_sec < 0)
 				timevalclear(&utv);
 		}
 		microtime(&tv0);
 		tvp = &utv;
 	} else
 		tvp = NULL;
 
 	error = kern_select(td, args->nfds, args->readfds, args->writefds,
 	    args->exceptfds, tvp, LINUX_NFDBITS);
 	if (error)
 		goto select_out;
 
 	if (args->timeout) {
 		if (td->td_retval[0]) {
 			/*
 			 * Compute how much time was left of the timeout,
 			 * by subtracting the current time and the time
 			 * before we started the call, and subtracting
 			 * that result from the user-supplied value.
 			 */
 			microtime(&tv1);
 			timevalsub(&tv1, &tv0);
 			timevalsub(&utv, &tv1);
 			if (utv.tv_sec < 0)
 				timevalclear(&utv);
 		} else
 			timevalclear(&utv);
 		ltv.tv_sec = utv.tv_sec;
 		ltv.tv_usec = utv.tv_usec;
 		if ((error = copyout(&ltv, args->timeout, sizeof(ltv))))
 			goto select_out;
 	}
 
 select_out:
 	return (error);
 }
 #endif
 
 int
 linux_mremap(struct thread *td, struct linux_mremap_args *args)
 {
 	uintptr_t addr;
 	size_t len;
 	int error = 0;
 
 	if (args->flags & ~(LINUX_MREMAP_FIXED | LINUX_MREMAP_MAYMOVE)) {
 		td->td_retval[0] = 0;
 		return (EINVAL);
 	}
 
 	/*
 	 * Check for the page alignment.
 	 * Linux defines PAGE_MASK to be FreeBSD ~PAGE_MASK.
 	 */
 	if (args->addr & PAGE_MASK) {
 		td->td_retval[0] = 0;
 		return (EINVAL);
 	}
 
 	args->new_len = round_page(args->new_len);
 	args->old_len = round_page(args->old_len);
 
 	if (args->new_len > args->old_len) {
 		td->td_retval[0] = 0;
 		return (ENOMEM);
 	}
 
 	if (args->new_len < args->old_len) {
 		addr = args->addr + args->new_len;
 		len = args->old_len - args->new_len;
 		error = kern_munmap(td, addr, len);
 	}
 
 	td->td_retval[0] = error ? 0 : (uintptr_t)args->addr;
 	return (error);
 }
 
 #define LINUX_MS_ASYNC       0x0001
 #define LINUX_MS_INVALIDATE  0x0002
 #define LINUX_MS_SYNC        0x0004
 
 int
 linux_msync(struct thread *td, struct linux_msync_args *args)
 {
 
 	return (kern_msync(td, args->addr, args->len,
 	    args->fl & ~LINUX_MS_SYNC));
 }
 
 #ifdef LINUX_LEGACY_SYSCALLS
 int
 linux_time(struct thread *td, struct linux_time_args *args)
 {
 	struct timeval tv;
 	l_time_t tm;
 	int error;
 
 	microtime(&tv);
 	tm = tv.tv_sec;
 	if (args->tm && (error = copyout(&tm, args->tm, sizeof(tm))))
 		return (error);
 	td->td_retval[0] = tm;
 	return (0);
 }
 #endif
 
 struct l_times_argv {
 	l_clock_t	tms_utime;
 	l_clock_t	tms_stime;
 	l_clock_t	tms_cutime;
 	l_clock_t	tms_cstime;
 };
 
 /*
  * Glibc versions prior to 2.2.1 always use hard-coded CLK_TCK value.
  * Since 2.2.1 Glibc uses value exported from kernel via AT_CLKTCK
  * auxiliary vector entry.
  */
 #define	CLK_TCK		100
 
 #define	CONVOTCK(r)	(r.tv_sec * CLK_TCK + r.tv_usec / (1000000 / CLK_TCK))
 #define	CONVNTCK(r)	(r.tv_sec * stclohz + r.tv_usec / (1000000 / stclohz))
 
 #define	CONVTCK(r)	(linux_kernver(td) >= LINUX_KERNVER_2004000 ?		\
 			    CONVNTCK(r) : CONVOTCK(r))
 
 int
 linux_times(struct thread *td, struct linux_times_args *args)
 {
 	struct timeval tv, utime, stime, cutime, cstime;
 	struct l_times_argv tms;
 	struct proc *p;
 	int error;
 
 	if (args->buf != NULL) {
 		p = td->td_proc;
 		PROC_LOCK(p);
 		PROC_STATLOCK(p);
 		calcru(p, &utime, &stime);
 		PROC_STATUNLOCK(p);
 		calccru(p, &cutime, &cstime);
 		PROC_UNLOCK(p);
 
 		tms.tms_utime = CONVTCK(utime);
 		tms.tms_stime = CONVTCK(stime);
 
 		tms.tms_cutime = CONVTCK(cutime);
 		tms.tms_cstime = CONVTCK(cstime);
 
 		if ((error = copyout(&tms, args->buf, sizeof(tms))))
 			return (error);
 	}
 
 	microuptime(&tv);
 	td->td_retval[0] = (int)CONVTCK(tv);
 	return (0);
 }
 
 int
 linux_newuname(struct thread *td, struct linux_newuname_args *args)
 {
 	struct l_new_utsname utsname;
 	char osname[LINUX_MAX_UTSNAME];
 	char osrelease[LINUX_MAX_UTSNAME];
 	char *p;
 
 	linux_get_osname(td, osname);
 	linux_get_osrelease(td, osrelease);
 
 	bzero(&utsname, sizeof(utsname));
 	strlcpy(utsname.sysname, osname, LINUX_MAX_UTSNAME);
 	getcredhostname(td->td_ucred, utsname.nodename, LINUX_MAX_UTSNAME);
 	getcreddomainname(td->td_ucred, utsname.domainname, LINUX_MAX_UTSNAME);
 	strlcpy(utsname.release, osrelease, LINUX_MAX_UTSNAME);
 	strlcpy(utsname.version, version, LINUX_MAX_UTSNAME);
 	for (p = utsname.version; *p != '\0'; ++p)
 		if (*p == '\n') {
 			*p = '\0';
 			break;
 		}
 #if defined(__amd64__)
 	/*
 	 * On amd64, Linux uname(2) needs to return "x86_64"
 	 * for both 64-bit and 32-bit applications.  On 32-bit,
 	 * the string returned by getauxval(AT_PLATFORM) needs
 	 * to remain "i686", though.
 	 */
 	strlcpy(utsname.machine, "x86_64", LINUX_MAX_UTSNAME);
 #else
 	strlcpy(utsname.machine, linux_kplatform, LINUX_MAX_UTSNAME);
 #endif
 
 	return (copyout(&utsname, args->buf, sizeof(utsname)));
 }
 
 struct l_utimbuf {
 	l_time_t l_actime;
 	l_time_t l_modtime;
 };
 
 #ifdef LINUX_LEGACY_SYSCALLS
 int
 linux_utime(struct thread *td, struct linux_utime_args *args)
 {
 	struct timeval tv[2], *tvp;
 	struct l_utimbuf lut;
 	char *fname;
 	int error;
 
 	if (args->times) {
 		if ((error = copyin(args->times, &lut, sizeof lut)) != 0)
 			return (error);
 		tv[0].tv_sec = lut.l_actime;
 		tv[0].tv_usec = 0;
 		tv[1].tv_sec = lut.l_modtime;
 		tv[1].tv_usec = 0;
 		tvp = tv;
 	} else
 		tvp = NULL;
 
 	if (!LUSECONVPATH(td)) {
 		error = kern_utimesat(td, AT_FDCWD, args->fname, UIO_USERSPACE,
 		    tvp, UIO_SYSSPACE);
 	} else {
 		LCONVPATHEXIST(td, args->fname, &fname);
 		error = kern_utimesat(td, AT_FDCWD, fname, UIO_SYSSPACE, tvp,
 		    UIO_SYSSPACE);
 		LFREEPATH(fname);
 	}
 	return (error);
 }
 #endif
 
 #ifdef LINUX_LEGACY_SYSCALLS
 int
 linux_utimes(struct thread *td, struct linux_utimes_args *args)
 {
 	l_timeval ltv[2];
 	struct timeval tv[2], *tvp = NULL;
 	char *fname;
 	int error;
 
 	if (args->tptr != NULL) {
 		if ((error = copyin(args->tptr, ltv, sizeof ltv)) != 0)
 			return (error);
 		tv[0].tv_sec = ltv[0].tv_sec;
 		tv[0].tv_usec = ltv[0].tv_usec;
 		tv[1].tv_sec = ltv[1].tv_sec;
 		tv[1].tv_usec = ltv[1].tv_usec;
 		tvp = tv;
 	}
 
 	if (!LUSECONVPATH(td)) {
 		error = kern_utimesat(td, AT_FDCWD, args->fname, UIO_USERSPACE,
 		    tvp, UIO_SYSSPACE);
 	} else {
 		LCONVPATHEXIST(td, args->fname, &fname);
 		error = kern_utimesat(td, AT_FDCWD, fname, UIO_SYSSPACE,
 		    tvp, UIO_SYSSPACE);
 		LFREEPATH(fname);
 	}
 	return (error);
 }
 #endif
 
 static int
 linux_utimensat_lts_to_ts(struct l_timespec *l_times, struct timespec *times)
 {
 
 	if (l_times->tv_nsec != LINUX_UTIME_OMIT &&
 	    l_times->tv_nsec != LINUX_UTIME_NOW &&
 	    (l_times->tv_nsec < 0 || l_times->tv_nsec > 999999999))
 		return (EINVAL);
 
 	times->tv_sec = l_times->tv_sec;
 	switch (l_times->tv_nsec)
 	{
 	case LINUX_UTIME_OMIT:
 		times->tv_nsec = UTIME_OMIT;
 		break;
 	case LINUX_UTIME_NOW:
 		times->tv_nsec = UTIME_NOW;
 		break;
 	default:
 		times->tv_nsec = l_times->tv_nsec;
 	}
 
 	return (0);
 }
 
 static int
 linux_common_utimensat(struct thread *td, int ldfd, const char *pathname,
     struct timespec *timesp, int lflags)
 {
 	char *path = NULL;
 	int error, dfd, flags = 0;
 
 	dfd = (ldfd == LINUX_AT_FDCWD) ? AT_FDCWD : ldfd;
 
 	if (lflags & ~(LINUX_AT_SYMLINK_NOFOLLOW | LINUX_AT_EMPTY_PATH))
 		return (EINVAL);
 
 	if (timesp != NULL) {
 		/* This breaks POSIX, but is what the Linux kernel does
 		 * _on purpose_ (documented in the man page for utimensat(2)),
 		 * so we must follow that behaviour. */
 		if (timesp[0].tv_nsec == UTIME_OMIT &&
 		    timesp[1].tv_nsec == UTIME_OMIT)
 			return (0);
 	}
 
 	if (lflags & LINUX_AT_SYMLINK_NOFOLLOW)
 		flags |= AT_SYMLINK_NOFOLLOW;
 	if (lflags & LINUX_AT_EMPTY_PATH)
 		flags |= AT_EMPTY_PATH;
 
 	if (!LUSECONVPATH(td)) {
 		if (pathname != NULL) {
 			return (kern_utimensat(td, dfd, pathname,
 			    UIO_USERSPACE, timesp, UIO_SYSSPACE, flags));
 		}
 	}
 
 	if (pathname != NULL)
 		LCONVPATHEXIST_AT(td, pathname, &path, dfd);
 	else if (lflags != 0)
 		return (EINVAL);
 
 	if (path == NULL)
 		error = kern_futimens(td, dfd, timesp, UIO_SYSSPACE);
 	else {
 		error = kern_utimensat(td, dfd, path, UIO_SYSSPACE, timesp,
 			UIO_SYSSPACE, flags);
 		LFREEPATH(path);
 	}
 
 	return (error);
 }
 
 int
 linux_utimensat(struct thread *td, struct linux_utimensat_args *args)
 {
 	struct l_timespec l_times[2];
 	struct timespec times[2], *timesp;
 	int error;
 
 	if (args->times != NULL) {
 		error = copyin(args->times, l_times, sizeof(l_times));
 		if (error != 0)
 			return (error);
 
 		error = linux_utimensat_lts_to_ts(&l_times[0], &times[0]);
 		if (error != 0)
 			return (error);
 		error = linux_utimensat_lts_to_ts(&l_times[1], &times[1]);
 		if (error != 0)
 			return (error);
 		timesp = times;
 	} else
 		timesp = NULL;
 
 	return (linux_common_utimensat(td, args->dfd, args->pathname,
 	    timesp, args->flags));
 }
 
 #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
 static int
 linux_utimensat_lts64_to_ts(struct l_timespec64 *l_times, struct timespec *times)
 {
 
 	if (l_times->tv_nsec != LINUX_UTIME_OMIT &&
 	    l_times->tv_nsec != LINUX_UTIME_NOW &&
 	    (l_times->tv_nsec < 0 || l_times->tv_nsec > 999999999))
 		return (EINVAL);
 
 	times->tv_sec = l_times->tv_sec;
 	switch (l_times->tv_nsec)
 	{
 	case LINUX_UTIME_OMIT:
 		times->tv_nsec = UTIME_OMIT;
 		break;
 	case LINUX_UTIME_NOW:
 		times->tv_nsec = UTIME_NOW;
 		break;
 	default:
 		times->tv_nsec = l_times->tv_nsec;
 	}
 
 	return (0);
 }
 
 int
 linux_utimensat_time64(struct thread *td, struct linux_utimensat_time64_args *args)
 {
 	struct l_timespec64 l_times[2];
 	struct timespec times[2], *timesp;
 	int error;
 
 	if (args->times64 != NULL) {
 		error = copyin(args->times64, l_times, sizeof(l_times));
 		if (error != 0)
 			return (error);
 
 		error = linux_utimensat_lts64_to_ts(&l_times[0], &times[0]);
 		if (error != 0)
 			return (error);
 		error = linux_utimensat_lts64_to_ts(&l_times[1], &times[1]);
 		if (error != 0)
 			return (error);
 		timesp = times;
 	} else
 		timesp = NULL;
 
 	return (linux_common_utimensat(td, args->dfd, args->pathname,
 	    timesp, args->flags));
 }
 #endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
 
 #ifdef LINUX_LEGACY_SYSCALLS
 int
 linux_futimesat(struct thread *td, struct linux_futimesat_args *args)
 {
 	l_timeval ltv[2];
 	struct timeval tv[2], *tvp = NULL;
 	char *fname;
 	int error, dfd;
 
 	dfd = (args->dfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->dfd;
 
 	if (args->utimes != NULL) {
 		if ((error = copyin(args->utimes, ltv, sizeof ltv)) != 0)
 			return (error);
 		tv[0].tv_sec = ltv[0].tv_sec;
 		tv[0].tv_usec = ltv[0].tv_usec;
 		tv[1].tv_sec = ltv[1].tv_sec;
 		tv[1].tv_usec = ltv[1].tv_usec;
 		tvp = tv;
 	}
 
 	if (!LUSECONVPATH(td)) {
 		error = kern_utimesat(td, dfd, args->filename, UIO_USERSPACE,
 		    tvp, UIO_SYSSPACE);
 	} else {
 		LCONVPATHEXIST_AT(td, args->filename, &fname, dfd);
 		error = kern_utimesat(td, dfd, fname, UIO_SYSSPACE,
 		    tvp, UIO_SYSSPACE);
 		LFREEPATH(fname);
 	}
 	return (error);
 }
 #endif
 
 static int
 linux_common_wait(struct thread *td, int pid, int *statusp,
     int options, struct __wrusage *wrup)
 {
 	siginfo_t siginfo;
 	idtype_t idtype;
 	id_t id;
 	int error, status, tmpstat;
 
 	if (pid == WAIT_ANY) {
 		idtype = P_ALL;
 		id = 0;
 	} else if (pid < 0) {
 		idtype = P_PGID;
 		id = (id_t)-pid;
 	} else {
 		idtype = P_PID;
 		id = (id_t)pid;
 	}
 
 	/*
 	 * For backward compatibility we implicitly add flags WEXITED
 	 * and WTRAPPED here.
 	 */
 	options |= WEXITED | WTRAPPED;
 	error = kern_wait6(td, idtype, id, &status, options, wrup, &siginfo);
 	if (error)
 		return (error);
 
 	if (statusp) {
 		tmpstat = status & 0xffff;
 		if (WIFSIGNALED(tmpstat)) {
 			tmpstat = (tmpstat & 0xffffff80) |
 			    bsd_to_linux_signal(WTERMSIG(tmpstat));
 		} else if (WIFSTOPPED(tmpstat)) {
 			tmpstat = (tmpstat & 0xffff00ff) |
 			    (bsd_to_linux_signal(WSTOPSIG(tmpstat)) << 8);
 #if defined(__amd64__) && !defined(COMPAT_LINUX32)
 			if (WSTOPSIG(status) == SIGTRAP) {
 				tmpstat = linux_ptrace_status(td,
 				    siginfo.si_pid, tmpstat);
 			}
 #endif
 		} else if (WIFCONTINUED(tmpstat)) {
 			tmpstat = 0xffff;
 		}
 		error = copyout(&tmpstat, statusp, sizeof(int));
 	}
 
 	return (error);
 }
 
 #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
 int
 linux_waitpid(struct thread *td, struct linux_waitpid_args *args)
 {
 	struct linux_wait4_args wait4_args;
 
 	wait4_args.pid = args->pid;
 	wait4_args.status = args->status;
 	wait4_args.options = args->options;
 	wait4_args.rusage = NULL;
 
 	return (linux_wait4(td, &wait4_args));
 }
 #endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
 
 int
 linux_wait4(struct thread *td, struct linux_wait4_args *args)
 {
 	int error, options;
 	struct __wrusage wru, *wrup;
 
 	if (args->options & ~(LINUX_WUNTRACED | LINUX_WNOHANG |
 	    LINUX_WCONTINUED | __WCLONE | __WNOTHREAD | __WALL))
 		return (EINVAL);
 
 	options = WEXITED;
 	linux_to_bsd_waitopts(args->options, &options);
 
 	if (args->rusage != NULL)
 		wrup = &wru;
 	else
 		wrup = NULL;
 	error = linux_common_wait(td, args->pid, args->status, options, wrup);
 	if (error != 0)
 		return (error);
 	if (args->rusage != NULL)
 		error = linux_copyout_rusage(&wru.wru_self, args->rusage);
 	return (error);
 }
 
 int
 linux_waitid(struct thread *td, struct linux_waitid_args *args)
 {
 	int status, options, sig;
 	struct __wrusage wru;
 	siginfo_t siginfo;
 	l_siginfo_t lsi;
 	idtype_t idtype;
 	struct proc *p;
 	int error;
 
 	options = 0;
 	linux_to_bsd_waitopts(args->options, &options);
 
 	if (options & ~(WNOHANG | WNOWAIT | WEXITED | WUNTRACED | WCONTINUED))
 		return (EINVAL);
 	if (!(options & (WEXITED | WUNTRACED | WCONTINUED)))
 		return (EINVAL);
 
 	switch (args->idtype) {
 	case LINUX_P_ALL:
 		idtype = P_ALL;
 		break;
 	case LINUX_P_PID:
 		if (args->id <= 0)
 			return (EINVAL);
 		idtype = P_PID;
 		break;
 	case LINUX_P_PGID:
 		if (args->id <= 0)
 			return (EINVAL);
 		idtype = P_PGID;
 		break;
 	default:
 		return (EINVAL);
 	}
 
 	error = kern_wait6(td, idtype, args->id, &status, options,
 	    &wru, &siginfo);
 	if (error != 0)
 		return (error);
 	if (args->rusage != NULL) {
 		error = linux_copyout_rusage(&wru.wru_children,
 		    args->rusage);
 		if (error != 0)
 			return (error);
 	}
 	if (args->info != NULL) {
 		p = td->td_proc;
 		bzero(&lsi, sizeof(lsi));
 		if (td->td_retval[0] != 0) {
 			sig = bsd_to_linux_signal(siginfo.si_signo);
 			siginfo_to_lsiginfo(&siginfo, &lsi, sig);
 		}
 		error = copyout(&lsi, args->info, sizeof(lsi));
 	}
 	td->td_retval[0] = 0;
 
 	return (error);
 }
 
 #ifdef LINUX_LEGACY_SYSCALLS
 int
 linux_mknod(struct thread *td, struct linux_mknod_args *args)
 {
 	char *path;
 	int error;
 	enum uio_seg seg;
 	bool convpath;
 
 	convpath = LUSECONVPATH(td);
 	if (!convpath) {
 		path = args->path;
 		seg = UIO_USERSPACE;
 	} else {
 		LCONVPATHCREAT(td, args->path, &path);
 		seg = UIO_SYSSPACE;
 	}
 
 	switch (args->mode & S_IFMT) {
 	case S_IFIFO:
 	case S_IFSOCK:
 		error = kern_mkfifoat(td, AT_FDCWD, path, seg,
 		    args->mode);
 		break;
 
 	case S_IFCHR:
 	case S_IFBLK:
 		error = kern_mknodat(td, AT_FDCWD, path, seg,
 		    args->mode, args->dev);
 		break;
 
 	case S_IFDIR:
 		error = EPERM;
 		break;
 
 	case 0:
 		args->mode |= S_IFREG;
 		/* FALLTHROUGH */
 	case S_IFREG:
 		error = kern_openat(td, AT_FDCWD, path, seg,
 		    O_WRONLY | O_CREAT | O_TRUNC, args->mode);
 		if (error == 0)
 			kern_close(td, td->td_retval[0]);
 		break;
 
 	default:
 		error = EINVAL;
 		break;
 	}
 	if (convpath)
 		LFREEPATH(path);
 	return (error);
 }
 #endif
 
 int
 linux_mknodat(struct thread *td, struct linux_mknodat_args *args)
 {
 	char *path;
 	int error, dfd;
 	enum uio_seg seg;
 	bool convpath;
 
 	dfd = (args->dfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->dfd;
 
 	convpath = LUSECONVPATH(td);
 	if (!convpath) {
 		path = __DECONST(char *, args->filename);
 		seg = UIO_USERSPACE;
 	} else {
 		LCONVPATHCREAT_AT(td, args->filename, &path, dfd);
 		seg = UIO_SYSSPACE;
 	}
 
 	switch (args->mode & S_IFMT) {
 	case S_IFIFO:
 	case S_IFSOCK:
 		error = kern_mkfifoat(td, dfd, path, seg, args->mode);
 		break;
 
 	case S_IFCHR:
 	case S_IFBLK:
 		error = kern_mknodat(td, dfd, path, seg, args->mode,
 		    args->dev);
 		break;
 
 	case S_IFDIR:
 		error = EPERM;
 		break;
 
 	case 0:
 		args->mode |= S_IFREG;
 		/* FALLTHROUGH */
 	case S_IFREG:
 		error = kern_openat(td, dfd, path, seg,
 		    O_WRONLY | O_CREAT | O_TRUNC, args->mode);
 		if (error == 0)
 			kern_close(td, td->td_retval[0]);
 		break;
 
 	default:
 		error = EINVAL;
 		break;
 	}
 	if (convpath)
 		LFREEPATH(path);
 	return (error);
 }
 
 /*
  * UGH! This is just about the dumbest idea I've ever heard!!
  */
 int
 linux_personality(struct thread *td, struct linux_personality_args *args)
 {
 	struct linux_pemuldata *pem;
 	struct proc *p = td->td_proc;
 	uint32_t old;
 
 	PROC_LOCK(p);
 	pem = pem_find(p);
 	old = pem->persona;
 	if (args->per != 0xffffffff)
 		pem->persona = args->per;
 	PROC_UNLOCK(p);
 
 	td->td_retval[0] = old;
 	return (0);
 }
 
 struct l_itimerval {
 	l_timeval it_interval;
 	l_timeval it_value;
 };
 
 #define	B2L_ITIMERVAL(bip, lip)						\
 	(bip)->it_interval.tv_sec = (lip)->it_interval.tv_sec;		\
 	(bip)->it_interval.tv_usec = (lip)->it_interval.tv_usec;	\
 	(bip)->it_value.tv_sec = (lip)->it_value.tv_sec;		\
 	(bip)->it_value.tv_usec = (lip)->it_value.tv_usec;
 
 int
 linux_setitimer(struct thread *td, struct linux_setitimer_args *uap)
 {
 	int error;
 	struct l_itimerval ls;
 	struct itimerval aitv, oitv;
 
 	if (uap->itv == NULL) {
 		uap->itv = uap->oitv;
 		return (linux_getitimer(td, (struct linux_getitimer_args *)uap));
 	}
 
 	error = copyin(uap->itv, &ls, sizeof(ls));
 	if (error != 0)
 		return (error);
 	B2L_ITIMERVAL(&aitv, &ls);
 	error = kern_setitimer(td, uap->which, &aitv, &oitv);
 	if (error != 0 || uap->oitv == NULL)
 		return (error);
 	B2L_ITIMERVAL(&ls, &oitv);
 
 	return (copyout(&ls, uap->oitv, sizeof(ls)));
 }
 
 int
 linux_getitimer(struct thread *td, struct linux_getitimer_args *uap)
 {
 	int error;
 	struct l_itimerval ls;
 	struct itimerval aitv;
 
 	error = kern_getitimer(td, uap->which, &aitv);
 	if (error != 0)
 		return (error);
 	B2L_ITIMERVAL(&ls, &aitv);
 	return (copyout(&ls, uap->itv, sizeof(ls)));
 }
 
 #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
 int
 linux_nice(struct thread *td, struct linux_nice_args *args)
 {
 
 	return (kern_setpriority(td, PRIO_PROCESS, 0, args->inc));
 }
 #endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
 
 int
 linux_setgroups(struct thread *td, struct linux_setgroups_args *args)
 {
 	struct ucred *newcred, *oldcred;
 	l_gid_t *linux_gidset;
 	gid_t *bsd_gidset;
 	int ngrp, error;
 	struct proc *p;
 
 	ngrp = args->gidsetsize;
 	if (ngrp < 0 || ngrp >= ngroups_max + 1)
 		return (EINVAL);
 	linux_gidset = malloc(ngrp * sizeof(*linux_gidset), M_LINUX, M_WAITOK);
 	error = copyin(args->grouplist, linux_gidset, ngrp * sizeof(l_gid_t));
 	if (error)
 		goto out;
 	newcred = crget();
 	crextend(newcred, ngrp + 1);
 	p = td->td_proc;
 	PROC_LOCK(p);
 	oldcred = p->p_ucred;
 	crcopy(newcred, oldcred);
 
 	/*
 	 * cr_groups[0] holds egid. Setting the whole set from
 	 * the supplied set will cause egid to be changed too.
 	 * Keep cr_groups[0] unchanged to prevent that.
 	 */
 
 	if ((error = priv_check_cred(oldcred, PRIV_CRED_SETGROUPS)) != 0) {
 		PROC_UNLOCK(p);
 		crfree(newcred);
 		goto out;
 	}
 
 	if (ngrp > 0) {
 		newcred->cr_ngroups = ngrp + 1;
 
 		bsd_gidset = newcred->cr_groups;
 		ngrp--;
 		while (ngrp >= 0) {
 			bsd_gidset[ngrp + 1] = linux_gidset[ngrp];
 			ngrp--;
 		}
 	} else
 		newcred->cr_ngroups = 1;
 
 	setsugid(p);
 	proc_set_cred(p, newcred);
 	PROC_UNLOCK(p);
 	crfree(oldcred);
 	error = 0;
 out:
 	free(linux_gidset, M_LINUX);
 	return (error);
 }
 
 int
 linux_getgroups(struct thread *td, struct linux_getgroups_args *args)
 {
 	struct ucred *cred;
 	l_gid_t *linux_gidset;
 	gid_t *bsd_gidset;
 	int bsd_gidsetsz, ngrp, error;
 
 	cred = td->td_ucred;
 	bsd_gidset = cred->cr_groups;
 	bsd_gidsetsz = cred->cr_ngroups - 1;
 
 	/*
 	 * cr_groups[0] holds egid. Returning the whole set
 	 * here will cause a duplicate. Exclude cr_groups[0]
 	 * to prevent that.
 	 */
 
 	if ((ngrp = args->gidsetsize) == 0) {
 		td->td_retval[0] = bsd_gidsetsz;
 		return (0);
 	}
 
 	if (ngrp < bsd_gidsetsz)
 		return (EINVAL);
 
 	ngrp = 0;
 	linux_gidset = malloc(bsd_gidsetsz * sizeof(*linux_gidset),
 	    M_LINUX, M_WAITOK);
 	while (ngrp < bsd_gidsetsz) {
 		linux_gidset[ngrp] = bsd_gidset[ngrp + 1];
 		ngrp++;
 	}
 
 	error = copyout(linux_gidset, args->grouplist, ngrp * sizeof(l_gid_t));
 	free(linux_gidset, M_LINUX);
 	if (error)
 		return (error);
 
 	td->td_retval[0] = ngrp;
 	return (0);
 }
 
 static bool
 linux_get_dummy_limit(l_uint resource, struct rlimit *rlim)
 {
 
 	if (linux_dummy_rlimits == 0)
 		return (false);
 
 	switch (resource) {
 	case LINUX_RLIMIT_LOCKS:
 	case LINUX_RLIMIT_SIGPENDING:
 	case LINUX_RLIMIT_MSGQUEUE:
 	case LINUX_RLIMIT_RTTIME:
 		rlim->rlim_cur = LINUX_RLIM_INFINITY;
 		rlim->rlim_max = LINUX_RLIM_INFINITY;
 		return (true);
 	case LINUX_RLIMIT_NICE:
 	case LINUX_RLIMIT_RTPRIO:
 		rlim->rlim_cur = 0;
 		rlim->rlim_max = 0;
 		return (true);
 	default:
 		return (false);
 	}
 }
 
 int
 linux_setrlimit(struct thread *td, struct linux_setrlimit_args *args)
 {
 	struct rlimit bsd_rlim;
 	struct l_rlimit rlim;
 	u_int which;
 	int error;
 
 	if (args->resource >= LINUX_RLIM_NLIMITS)
 		return (EINVAL);
 
 	which = linux_to_bsd_resource[args->resource];
 	if (which == -1)
 		return (EINVAL);
 
 	error = copyin(args->rlim, &rlim, sizeof(rlim));
 	if (error)
 		return (error);
 
 	bsd_rlim.rlim_cur = (rlim_t)rlim.rlim_cur;
 	bsd_rlim.rlim_max = (rlim_t)rlim.rlim_max;
 	return (kern_setrlimit(td, which, &bsd_rlim));
 }
 
 #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
 int
 linux_old_getrlimit(struct thread *td, struct linux_old_getrlimit_args *args)
 {
 	struct l_rlimit rlim;
 	struct rlimit bsd_rlim;
 	u_int which;
 
 	if (linux_get_dummy_limit(args->resource, &bsd_rlim)) {
 		rlim.rlim_cur = bsd_rlim.rlim_cur;
 		rlim.rlim_max = bsd_rlim.rlim_max;
 		return (copyout(&rlim, args->rlim, sizeof(rlim)));
 	}
 
 	if (args->resource >= LINUX_RLIM_NLIMITS)
 		return (EINVAL);
 
 	which = linux_to_bsd_resource[args->resource];
 	if (which == -1)
 		return (EINVAL);
 
 	lim_rlimit(td, which, &bsd_rlim);
 
 #ifdef COMPAT_LINUX32
 	rlim.rlim_cur = (unsigned int)bsd_rlim.rlim_cur;
 	if (rlim.rlim_cur == UINT_MAX)
 		rlim.rlim_cur = INT_MAX;
 	rlim.rlim_max = (unsigned int)bsd_rlim.rlim_max;
 	if (rlim.rlim_max == UINT_MAX)
 		rlim.rlim_max = INT_MAX;
 #else
 	rlim.rlim_cur = (unsigned long)bsd_rlim.rlim_cur;
 	if (rlim.rlim_cur == ULONG_MAX)
 		rlim.rlim_cur = LONG_MAX;
 	rlim.rlim_max = (unsigned long)bsd_rlim.rlim_max;
 	if (rlim.rlim_max == ULONG_MAX)
 		rlim.rlim_max = LONG_MAX;
 #endif
 	return (copyout(&rlim, args->rlim, sizeof(rlim)));
 }
 #endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
 
 int
 linux_getrlimit(struct thread *td, struct linux_getrlimit_args *args)
 {
 	struct l_rlimit rlim;
 	struct rlimit bsd_rlim;
 	u_int which;
 
 	if (linux_get_dummy_limit(args->resource, &bsd_rlim)) {
 		rlim.rlim_cur = bsd_rlim.rlim_cur;
 		rlim.rlim_max = bsd_rlim.rlim_max;
 		return (copyout(&rlim, args->rlim, sizeof(rlim)));
 	}
 
 	if (args->resource >= LINUX_RLIM_NLIMITS)
 		return (EINVAL);
 
 	which = linux_to_bsd_resource[args->resource];
 	if (which == -1)
 		return (EINVAL);
 
 	lim_rlimit(td, which, &bsd_rlim);
 
 	rlim.rlim_cur = (l_ulong)bsd_rlim.rlim_cur;
 	rlim.rlim_max = (l_ulong)bsd_rlim.rlim_max;
 	return (copyout(&rlim, args->rlim, sizeof(rlim)));
 }
 
 int
 linux_sched_setscheduler(struct thread *td,
     struct linux_sched_setscheduler_args *args)
 {
 	struct sched_param sched_param;
 	struct thread *tdt;
 	int error, policy;
 
 	switch (args->policy) {
 	case LINUX_SCHED_OTHER:
 		policy = SCHED_OTHER;
 		break;
 	case LINUX_SCHED_FIFO:
 		policy = SCHED_FIFO;
 		break;
 	case LINUX_SCHED_RR:
 		policy = SCHED_RR;
 		break;
 	default:
 		return (EINVAL);
 	}
 
 	error = copyin(args->param, &sched_param, sizeof(sched_param));
 	if (error)
 		return (error);
 
 	if (linux_map_sched_prio) {
 		switch (policy) {
 		case SCHED_OTHER:
 			if (sched_param.sched_priority != 0)
 				return (EINVAL);
 
 			sched_param.sched_priority =
 			    PRI_MAX_TIMESHARE - PRI_MIN_TIMESHARE;
 			break;
 		case SCHED_FIFO:
 		case SCHED_RR:
 			if (sched_param.sched_priority < 1 ||
 			    sched_param.sched_priority >= LINUX_MAX_RT_PRIO)
 				return (EINVAL);
 
 			/*
 			 * Map [1, LINUX_MAX_RT_PRIO - 1] to
 			 * [0, RTP_PRIO_MAX - RTP_PRIO_MIN] (rounding down).
 			 */
 			sched_param.sched_priority =
 			    (sched_param.sched_priority - 1) *
 			    (RTP_PRIO_MAX - RTP_PRIO_MIN + 1) /
 			    (LINUX_MAX_RT_PRIO - 1);
 			break;
 		}
 	}
 
 	tdt = linux_tdfind(td, args->pid, -1);
 	if (tdt == NULL)
 		return (ESRCH);
 
 	error = kern_sched_setscheduler(td, tdt, policy, &sched_param);
 	PROC_UNLOCK(tdt->td_proc);
 	return (error);
 }
 
 int
 linux_sched_getscheduler(struct thread *td,
     struct linux_sched_getscheduler_args *args)
 {
 	struct thread *tdt;
 	int error, policy;
 
 	tdt = linux_tdfind(td, args->pid, -1);
 	if (tdt == NULL)
 		return (ESRCH);
 
 	error = kern_sched_getscheduler(td, tdt, &policy);
 	PROC_UNLOCK(tdt->td_proc);
 
 	switch (policy) {
 	case SCHED_OTHER:
 		td->td_retval[0] = LINUX_SCHED_OTHER;
 		break;
 	case SCHED_FIFO:
 		td->td_retval[0] = LINUX_SCHED_FIFO;
 		break;
 	case SCHED_RR:
 		td->td_retval[0] = LINUX_SCHED_RR;
 		break;
 	}
 	return (error);
 }
 
 int
 linux_sched_get_priority_max(struct thread *td,
     struct linux_sched_get_priority_max_args *args)
 {
 	struct sched_get_priority_max_args bsd;
 
 	if (linux_map_sched_prio) {
 		switch (args->policy) {
 		case LINUX_SCHED_OTHER:
 			td->td_retval[0] = 0;
 			return (0);
 		case LINUX_SCHED_FIFO:
 		case LINUX_SCHED_RR:
 			td->td_retval[0] = LINUX_MAX_RT_PRIO - 1;
 			return (0);
 		default:
 			return (EINVAL);
 		}
 	}
 
 	switch (args->policy) {
 	case LINUX_SCHED_OTHER:
 		bsd.policy = SCHED_OTHER;
 		break;
 	case LINUX_SCHED_FIFO:
 		bsd.policy = SCHED_FIFO;
 		break;
 	case LINUX_SCHED_RR:
 		bsd.policy = SCHED_RR;
 		break;
 	default:
 		return (EINVAL);
 	}
 	return (sys_sched_get_priority_max(td, &bsd));
 }
 
 int
 linux_sched_get_priority_min(struct thread *td,
     struct linux_sched_get_priority_min_args *args)
 {
 	struct sched_get_priority_min_args bsd;
 
 	if (linux_map_sched_prio) {
 		switch (args->policy) {
 		case LINUX_SCHED_OTHER:
 			td->td_retval[0] = 0;
 			return (0);
 		case LINUX_SCHED_FIFO:
 		case LINUX_SCHED_RR:
 			td->td_retval[0] = 1;
 			return (0);
 		default:
 			return (EINVAL);
 		}
 	}
 
 	switch (args->policy) {
 	case LINUX_SCHED_OTHER:
 		bsd.policy = SCHED_OTHER;
 		break;
 	case LINUX_SCHED_FIFO:
 		bsd.policy = SCHED_FIFO;
 		break;
 	case LINUX_SCHED_RR:
 		bsd.policy = SCHED_RR;
 		break;
 	default:
 		return (EINVAL);
 	}
 	return (sys_sched_get_priority_min(td, &bsd));
 }
 
 #define REBOOT_CAD_ON	0x89abcdef
 #define REBOOT_CAD_OFF	0
 #define REBOOT_HALT	0xcdef0123
 #define REBOOT_RESTART	0x01234567
 #define REBOOT_RESTART2	0xA1B2C3D4
 #define REBOOT_POWEROFF	0x4321FEDC
 #define REBOOT_MAGIC1	0xfee1dead
 #define REBOOT_MAGIC2	0x28121969
 #define REBOOT_MAGIC2A	0x05121996
 #define REBOOT_MAGIC2B	0x16041998
 
 int
 linux_reboot(struct thread *td, struct linux_reboot_args *args)
 {
 	struct reboot_args bsd_args;
 
 	if (args->magic1 != REBOOT_MAGIC1)
 		return (EINVAL);
 
 	switch (args->magic2) {
 	case REBOOT_MAGIC2:
 	case REBOOT_MAGIC2A:
 	case REBOOT_MAGIC2B:
 		break;
 	default:
 		return (EINVAL);
 	}
 
 	switch (args->cmd) {
 	case REBOOT_CAD_ON:
 	case REBOOT_CAD_OFF:
 		return (priv_check(td, PRIV_REBOOT));
 	case REBOOT_HALT:
 		bsd_args.opt = RB_HALT;
 		break;
 	case REBOOT_RESTART:
 	case REBOOT_RESTART2:
 		bsd_args.opt = 0;
 		break;
 	case REBOOT_POWEROFF:
 		bsd_args.opt = RB_POWEROFF;
 		break;
 	default:
 		return (EINVAL);
 	}
 	return (sys_reboot(td, &bsd_args));
 }
 
 int
 linux_getpid(struct thread *td, struct linux_getpid_args *args)
 {
 
 	td->td_retval[0] = td->td_proc->p_pid;
 
 	return (0);
 }
 
 int
 linux_gettid(struct thread *td, struct linux_gettid_args *args)
 {
 	struct linux_emuldata *em;
 
 	em = em_find(td);
 	KASSERT(em != NULL, ("gettid: emuldata not found.\n"));
 
 	td->td_retval[0] = em->em_tid;
 
 	return (0);
 }
 
 int
 linux_getppid(struct thread *td, struct linux_getppid_args *args)
 {
 
 	td->td_retval[0] = kern_getppid(td);
 	return (0);
 }
 
 int
 linux_getgid(struct thread *td, struct linux_getgid_args *args)
 {
 
 	td->td_retval[0] = td->td_ucred->cr_rgid;
 	return (0);
 }
 
 int
 linux_getuid(struct thread *td, struct linux_getuid_args *args)
 {
 
 	td->td_retval[0] = td->td_ucred->cr_ruid;
 	return (0);
 }
 
 int
 linux_getsid(struct thread *td, struct linux_getsid_args *args)
 {
 
 	return (kern_getsid(td, args->pid));
 }
 
 int
 linux_nosys(struct thread *td, struct nosys_args *ignore)
 {
 
 	return (ENOSYS);
 }
 
 int
 linux_getpriority(struct thread *td, struct linux_getpriority_args *args)
 {
 	int error;
 
 	error = kern_getpriority(td, args->which, args->who);
 	td->td_retval[0] = 20 - td->td_retval[0];
 	return (error);
 }
 
 int
 linux_sethostname(struct thread *td, struct linux_sethostname_args *args)
 {
 	int name[2];
 
 	name[0] = CTL_KERN;
 	name[1] = KERN_HOSTNAME;
 	return (userland_sysctl(td, name, 2, 0, 0, 0, args->hostname,
 	    args->len, 0, 0));
 }
 
 int
 linux_setdomainname(struct thread *td, struct linux_setdomainname_args *args)
 {
 	int name[2];
 
 	name[0] = CTL_KERN;
 	name[1] = KERN_NISDOMAINNAME;
 	return (userland_sysctl(td, name, 2, 0, 0, 0, args->name,
 	    args->len, 0, 0));
 }
 
 int
 linux_exit_group(struct thread *td, struct linux_exit_group_args *args)
 {
 
 	LINUX_CTR2(exit_group, "thread(%d) (%d)", td->td_tid,
 	    args->error_code);
 
 	/*
 	 * XXX: we should send a signal to the parent if
 	 * SIGNAL_EXIT_GROUP is set. We ignore that (temporarily?)
 	 * as it doesnt occur often.
 	 */
 	exit1(td, args->error_code, 0);
 		/* NOTREACHED */
 }
 
 #define _LINUX_CAPABILITY_VERSION_1  0x19980330
 #define _LINUX_CAPABILITY_VERSION_2  0x20071026
 #define _LINUX_CAPABILITY_VERSION_3  0x20080522
 
 struct l_user_cap_header {
 	l_int	version;
 	l_int	pid;
 };
 
 struct l_user_cap_data {
 	l_int	effective;
 	l_int	permitted;
 	l_int	inheritable;
 };
 
 int
 linux_capget(struct thread *td, struct linux_capget_args *uap)
 {
 	struct l_user_cap_header luch;
 	struct l_user_cap_data lucd[2];
 	int error, u32s;
 
 	if (uap->hdrp == NULL)
 		return (EFAULT);
 
 	error = copyin(uap->hdrp, &luch, sizeof(luch));
 	if (error != 0)
 		return (error);
 
 	switch (luch.version) {
 	case _LINUX_CAPABILITY_VERSION_1:
 		u32s = 1;
 		break;
 	case _LINUX_CAPABILITY_VERSION_2:
 	case _LINUX_CAPABILITY_VERSION_3:
 		u32s = 2;
 		break;
 	default:
 		luch.version = _LINUX_CAPABILITY_VERSION_1;
 		error = copyout(&luch, uap->hdrp, sizeof(luch));
 		if (error)
 			return (error);
 		return (EINVAL);
 	}
 
 	if (luch.pid)
 		return (EPERM);
 
 	if (uap->datap) {
 		/*
 		 * The current implementation doesn't support setting
 		 * a capability (it's essentially a stub) so indicate
 		 * that no capabilities are currently set or available
 		 * to request.
 		 */
 		memset(&lucd, 0, u32s * sizeof(lucd[0]));
 		error = copyout(&lucd, uap->datap, u32s * sizeof(lucd[0]));
 	}
 
 	return (error);
 }
 
 int
 linux_capset(struct thread *td, struct linux_capset_args *uap)
 {
 	struct l_user_cap_header luch;
 	struct l_user_cap_data lucd[2];
 	int error, i, u32s;
 
 	if (uap->hdrp == NULL || uap->datap == NULL)
 		return (EFAULT);
 
 	error = copyin(uap->hdrp, &luch, sizeof(luch));
 	if (error != 0)
 		return (error);
 
 	switch (luch.version) {
 	case _LINUX_CAPABILITY_VERSION_1:
 		u32s = 1;
 		break;
 	case _LINUX_CAPABILITY_VERSION_2:
 	case _LINUX_CAPABILITY_VERSION_3:
 		u32s = 2;
 		break;
 	default:
 		luch.version = _LINUX_CAPABILITY_VERSION_1;
 		error = copyout(&luch, uap->hdrp, sizeof(luch));
 		if (error)
 			return (error);
 		return (EINVAL);
 	}
 
 	if (luch.pid)
 		return (EPERM);
 
 	error = copyin(uap->datap, &lucd, u32s * sizeof(lucd[0]));
 	if (error != 0)
 		return (error);
 
 	/* We currently don't support setting any capabilities. */
 	for (i = 0; i < u32s; i++) {
 		if (lucd[i].effective || lucd[i].permitted ||
 		    lucd[i].inheritable) {
 			linux_msg(td,
 			    "capset[%d] effective=0x%x, permitted=0x%x, "
 			    "inheritable=0x%x is not implemented", i,
 			    (int)lucd[i].effective, (int)lucd[i].permitted,
 			    (int)lucd[i].inheritable);
 			return (EPERM);
 		}
 	}
 
 	return (0);
 }
 
 int
 linux_prctl(struct thread *td, struct linux_prctl_args *args)
 {
 	int error = 0, max_size;
 	struct proc *p = td->td_proc;
 	char comm[LINUX_MAX_COMM_LEN];
 	int pdeath_signal, trace_state;
 
 	switch (args->option) {
 	case LINUX_PR_SET_PDEATHSIG:
 		if (!LINUX_SIG_VALID(args->arg2))
 			return (EINVAL);
 		pdeath_signal = linux_to_bsd_signal(args->arg2);
 		return (kern_procctl(td, P_PID, 0, PROC_PDEATHSIG_CTL,
 		    &pdeath_signal));
 	case LINUX_PR_GET_PDEATHSIG:
 		error = kern_procctl(td, P_PID, 0, PROC_PDEATHSIG_STATUS,
 		    &pdeath_signal);
 		if (error != 0)
 			return (error);
 		pdeath_signal = bsd_to_linux_signal(pdeath_signal);
 		return (copyout(&pdeath_signal,
 		    (void *)(register_t)args->arg2,
 		    sizeof(pdeath_signal)));
 	/*
 	 * In Linux, this flag controls if set[gu]id processes can coredump.
 	 * There are additional semantics imposed on processes that cannot
 	 * coredump:
 	 * - Such processes can not be ptraced.
 	 * - There are some semantics around ownership of process-related files
 	 *   in the /proc namespace.
 	 *
 	 * In FreeBSD, we can (and by default, do) disable setuid coredump
 	 * system-wide with 'sugid_coredump.'  We control tracability on a
 	 * per-process basis with the procctl PROC_TRACE (=> P2_NOTRACE flag).
 	 * By happy coincidence, P2_NOTRACE also prevents coredumping.  So the
 	 * procctl is roughly analogous to Linux's DUMPABLE.
 	 *
 	 * So, proxy these knobs to the corresponding PROC_TRACE setting.
 	 */
 	case LINUX_PR_GET_DUMPABLE:
 		error = kern_procctl(td, P_PID, p->p_pid, PROC_TRACE_STATUS,
 		    &trace_state);
 		if (error != 0)
 			return (error);
 		td->td_retval[0] = (trace_state != -1);
 		return (0);
 	case LINUX_PR_SET_DUMPABLE:
 		/*
 		 * It is only valid for userspace to set one of these two
 		 * flags, and only one at a time.
 		 */
 		switch (args->arg2) {
 		case LINUX_SUID_DUMP_DISABLE:
 			trace_state = PROC_TRACE_CTL_DISABLE_EXEC;
 			break;
 		case LINUX_SUID_DUMP_USER:
 			trace_state = PROC_TRACE_CTL_ENABLE;
 			break;
 		default:
 			return (EINVAL);
 		}
 		return (kern_procctl(td, P_PID, p->p_pid, PROC_TRACE_CTL,
 		    &trace_state));
 	case LINUX_PR_GET_KEEPCAPS:
 		/*
 		 * Indicate that we always clear the effective and
 		 * permitted capability sets when the user id becomes
 		 * non-zero (actually the capability sets are simply
 		 * always zero in the current implementation).
 		 */
 		td->td_retval[0] = 0;
 		break;
 	case LINUX_PR_SET_KEEPCAPS:
 		/*
 		 * Ignore requests to keep the effective and permitted
 		 * capability sets when the user id becomes non-zero.
 		 */
 		break;
 	case LINUX_PR_SET_NAME:
 		/*
 		 * To be on the safe side we need to make sure to not
 		 * overflow the size a Linux program expects. We already
 		 * do this here in the copyin, so that we don't need to
 		 * check on copyout.
 		 */
 		max_size = MIN(sizeof(comm), sizeof(p->p_comm));
 		error = copyinstr((void *)(register_t)args->arg2, comm,
 		    max_size, NULL);
 
 		/* Linux silently truncates the name if it is too long. */
 		if (error == ENAMETOOLONG) {
 			/*
 			 * XXX: copyinstr() isn't documented to populate the
 			 * array completely, so do a copyin() to be on the
 			 * safe side. This should be changed in case
 			 * copyinstr() is changed to guarantee this.
 			 */
 			error = copyin((void *)(register_t)args->arg2, comm,
 			    max_size - 1);
 			comm[max_size - 1] = '\0';
 		}
 		if (error)
 			return (error);
 
 		PROC_LOCK(p);
 		strlcpy(p->p_comm, comm, sizeof(p->p_comm));
 		PROC_UNLOCK(p);
 		break;
 	case LINUX_PR_GET_NAME:
 		PROC_LOCK(p);
 		strlcpy(comm, p->p_comm, sizeof(comm));
 		PROC_UNLOCK(p);
 		error = copyout(comm, (void *)(register_t)args->arg2,
 		    strlen(comm) + 1);
 		break;
 	case LINUX_PR_GET_SECCOMP:
 	case LINUX_PR_SET_SECCOMP:
 		/*
 		 * Same as returned by Linux without CONFIG_SECCOMP enabled.
 		 */
 		error = EINVAL;
 		break;
 	case LINUX_PR_CAPBSET_READ:
 #if 0
 		/*
 		 * This makes too much noise with Ubuntu Focal.
 		 */
 		linux_msg(td, "unsupported prctl PR_CAPBSET_READ %d",
 		    (int)args->arg2);
 #endif
 		error = EINVAL;
 		break;
 	case LINUX_PR_SET_NO_NEW_PRIVS:
 		linux_msg(td, "unsupported prctl PR_SET_NO_NEW_PRIVS");
 		error = EINVAL;
 		break;
 	case LINUX_PR_SET_PTRACER:
 		linux_msg(td, "unsupported prctl PR_SET_PTRACER");
 		error = EINVAL;
 		break;
 	default:
 		linux_msg(td, "unsupported prctl option %d", args->option);
 		error = EINVAL;
 		break;
 	}
 
 	return (error);
 }
 
 int
 linux_sched_setparam(struct thread *td,
     struct linux_sched_setparam_args *uap)
 {
 	struct sched_param sched_param;
 	struct thread *tdt;
 	int error, policy;
 
 	error = copyin(uap->param, &sched_param, sizeof(sched_param));
 	if (error)
 		return (error);
 
 	tdt = linux_tdfind(td, uap->pid, -1);
 	if (tdt == NULL)
 		return (ESRCH);
 
 	if (linux_map_sched_prio) {
 		error = kern_sched_getscheduler(td, tdt, &policy);
 		if (error)
 			goto out;
 
 		switch (policy) {
 		case SCHED_OTHER:
 			if (sched_param.sched_priority != 0) {
 				error = EINVAL;
 				goto out;
 			}
 			sched_param.sched_priority =
 			    PRI_MAX_TIMESHARE - PRI_MIN_TIMESHARE;
 			break;
 		case SCHED_FIFO:
 		case SCHED_RR:
 			if (sched_param.sched_priority < 1 ||
 			    sched_param.sched_priority >= LINUX_MAX_RT_PRIO) {
 				error = EINVAL;
 				goto out;
 			}
 			/*
 			 * Map [1, LINUX_MAX_RT_PRIO - 1] to
 			 * [0, RTP_PRIO_MAX - RTP_PRIO_MIN] (rounding down).
 			 */
 			sched_param.sched_priority =
 			    (sched_param.sched_priority - 1) *
 			    (RTP_PRIO_MAX - RTP_PRIO_MIN + 1) /
 			    (LINUX_MAX_RT_PRIO - 1);
 			break;
 		}
 	}
 
 	error = kern_sched_setparam(td, tdt, &sched_param);
 out:	PROC_UNLOCK(tdt->td_proc);
 	return (error);
 }
 
 int
 linux_sched_getparam(struct thread *td,
     struct linux_sched_getparam_args *uap)
 {
 	struct sched_param sched_param;
 	struct thread *tdt;
 	int error, policy;
 
 	tdt = linux_tdfind(td, uap->pid, -1);
 	if (tdt == NULL)
 		return (ESRCH);
 
 	error = kern_sched_getparam(td, tdt, &sched_param);
 	if (error) {
 		PROC_UNLOCK(tdt->td_proc);
 		return (error);
 	}
 
 	if (linux_map_sched_prio) {
 		error = kern_sched_getscheduler(td, tdt, &policy);
 		PROC_UNLOCK(tdt->td_proc);
 		if (error)
 			return (error);
 
 		switch (policy) {
 		case SCHED_OTHER:
 			sched_param.sched_priority = 0;
 			break;
 		case SCHED_FIFO:
 		case SCHED_RR:
 			/*
 			 * Map [0, RTP_PRIO_MAX - RTP_PRIO_MIN] to
 			 * [1, LINUX_MAX_RT_PRIO - 1] (rounding up).
 			 */
 			sched_param.sched_priority =
 			    (sched_param.sched_priority *
 			    (LINUX_MAX_RT_PRIO - 1) +
 			    (RTP_PRIO_MAX - RTP_PRIO_MIN - 1)) /
 			    (RTP_PRIO_MAX - RTP_PRIO_MIN) + 1;
 			break;
 		}
 	} else
 		PROC_UNLOCK(tdt->td_proc);
 
 	error = copyout(&sched_param, uap->param, sizeof(sched_param));
 	return (error);
 }
 
 /*
  * Get affinity of a process.
  */
 int
 linux_sched_getaffinity(struct thread *td,
     struct linux_sched_getaffinity_args *args)
 {
 	int error;
 	struct thread *tdt;
 
 	if (args->len < sizeof(cpuset_t))
 		return (EINVAL);
 
 	tdt = linux_tdfind(td, args->pid, -1);
 	if (tdt == NULL)
 		return (ESRCH);
 
 	PROC_UNLOCK(tdt->td_proc);
 
 	error = kern_cpuset_getaffinity(td, CPU_LEVEL_WHICH, CPU_WHICH_TID,
 	    tdt->td_tid, sizeof(cpuset_t), (cpuset_t *)args->user_mask_ptr);
 	if (error == 0)
 		td->td_retval[0] = sizeof(cpuset_t);
 
 	return (error);
 }
 
 /*
  *  Set affinity of a process.
  */
 int
 linux_sched_setaffinity(struct thread *td,
     struct linux_sched_setaffinity_args *args)
 {
 	struct thread *tdt;
 
 	if (args->len < sizeof(cpuset_t))
 		return (EINVAL);
 
 	tdt = linux_tdfind(td, args->pid, -1);
 	if (tdt == NULL)
 		return (ESRCH);
 
 	PROC_UNLOCK(tdt->td_proc);
 
 	return (kern_cpuset_setaffinity(td, CPU_LEVEL_WHICH, CPU_WHICH_TID,
 	    tdt->td_tid, sizeof(cpuset_t), (cpuset_t *) args->user_mask_ptr));
 }
 
 struct linux_rlimit64 {
 	uint64_t	rlim_cur;
 	uint64_t	rlim_max;
 };
 
 int
 linux_prlimit64(struct thread *td, struct linux_prlimit64_args *args)
 {
 	struct rlimit rlim, nrlim;
 	struct linux_rlimit64 lrlim;
 	struct proc *p;
 	u_int which;
 	int flags;
 	int error;
 
 	if (args->new == NULL && args->old != NULL) {
 		if (linux_get_dummy_limit(args->resource, &rlim)) {
 			lrlim.rlim_cur = rlim.rlim_cur;
 			lrlim.rlim_max = rlim.rlim_max;
 			return (copyout(&lrlim, args->old, sizeof(lrlim)));
 		}
 	}
 
 	if (args->resource >= LINUX_RLIM_NLIMITS)
 		return (EINVAL);
 
 	which = linux_to_bsd_resource[args->resource];
 	if (which == -1)
 		return (EINVAL);
 
 	if (args->new != NULL) {
 		/*
 		 * Note. Unlike FreeBSD where rlim is signed 64-bit Linux
 		 * rlim is unsigned 64-bit. FreeBSD treats negative limits
 		 * as INFINITY so we do not need a conversion even.
 		 */
 		error = copyin(args->new, &nrlim, sizeof(nrlim));
 		if (error != 0)
 			return (error);
 	}
 
 	flags = PGET_HOLD | PGET_NOTWEXIT;
 	if (args->new != NULL)
 		flags |= PGET_CANDEBUG;
 	else
 		flags |= PGET_CANSEE;
 	if (args->pid == 0) {
 		p = td->td_proc;
 		PHOLD(p);
 	} else {
 		error = pget(args->pid, flags, &p);
 		if (error != 0)
 			return (error);
 	}
 	if (args->old != NULL) {
 		PROC_LOCK(p);
 		lim_rlimit_proc(p, which, &rlim);
 		PROC_UNLOCK(p);
 		if (rlim.rlim_cur == RLIM_INFINITY)
 			lrlim.rlim_cur = LINUX_RLIM_INFINITY;
 		else
 			lrlim.rlim_cur = rlim.rlim_cur;
 		if (rlim.rlim_max == RLIM_INFINITY)
 			lrlim.rlim_max = LINUX_RLIM_INFINITY;
 		else
 			lrlim.rlim_max = rlim.rlim_max;
 		error = copyout(&lrlim, args->old, sizeof(lrlim));
 		if (error != 0)
 			goto out;
 	}
 
 	if (args->new != NULL)
 		error = kern_proc_setrlimit(td, p, which, &nrlim);
 
  out:
 	PRELE(p);
 	return (error);
 }
 
 int
 linux_pselect6(struct thread *td, struct linux_pselect6_args *args)
 {
 	struct l_timespec lts;
 	struct timespec ts, *tsp;
 	int error;
 
 	if (args->tsp != NULL) {
 		error = copyin(args->tsp, &lts, sizeof(lts));
 		if (error != 0)
 			return (error);
 		error = linux_to_native_timespec(&ts, &lts);
 		if (error != 0)
 			return (error);
 		tsp = &ts;
 	} else
 		tsp = NULL;
 
 	error = linux_common_pselect6(td, args->nfds, args->readfds,
 	    args->writefds, args->exceptfds, tsp, args->sig);
 	if (error != 0)
 		return (error);
 
 	if (args->tsp != NULL) {
 		error = native_to_linux_timespec(&lts, tsp);
 		if (error == 0)
 			error = copyout(&lts, args->tsp, sizeof(lts));
 	}
 	return (error);
 }
 
 static int
 linux_common_pselect6(struct thread *td, l_int nfds, l_fd_set *readfds,
     l_fd_set *writefds, l_fd_set *exceptfds, struct timespec *tsp,
     l_uintptr_t *sig)
 {
 	struct timeval utv, tv0, tv1, *tvp;
 	struct l_pselect6arg lpse6;
 	l_sigset_t l_ss;
 	sigset_t *ssp;
 	sigset_t ss;
 	int error;
 
 	ssp = NULL;
 	if (sig != NULL) {
 		error = copyin(sig, &lpse6, sizeof(lpse6));
 		if (error != 0)
 			return (error);
 		if (lpse6.ss_len != sizeof(l_ss))
 			return (EINVAL);
 		if (lpse6.ss != 0) {
 			error = copyin(PTRIN(lpse6.ss), &l_ss,
 			    sizeof(l_ss));
 			if (error != 0)
 				return (error);
 			linux_to_bsd_sigset(&l_ss, &ss);
 			ssp = &ss;
 		}
 	} else
 		ssp = NULL;
 
 	/*
 	 * Currently glibc changes nanosecond number to microsecond.
 	 * This mean losing precision but for now it is hardly seen.
 	 */
 	if (tsp != NULL) {
 		TIMESPEC_TO_TIMEVAL(&utv, tsp);
 		if (itimerfix(&utv))
 			return (EINVAL);
 
 		microtime(&tv0);
 		tvp = &utv;
 	} else
 		tvp = NULL;
 
 	error = kern_pselect(td, nfds, readfds, writefds,
 	    exceptfds, tvp, ssp, LINUX_NFDBITS);
 
 	if (error == 0 && tsp != NULL) {
 		if (td->td_retval[0] != 0) {
 			/*
 			 * Compute how much time was left of the timeout,
 			 * by subtracting the current time and the time
 			 * before we started the call, and subtracting
 			 * that result from the user-supplied value.
 			 */
 
 			microtime(&tv1);
 			timevalsub(&tv1, &tv0);
 			timevalsub(&utv, &tv1);
 			if (utv.tv_sec < 0)
 				timevalclear(&utv);
 		} else
 			timevalclear(&utv);
 		TIMEVAL_TO_TIMESPEC(&utv, tsp);
 	}
 	return (error);
 }
 
 #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
 int
 linux_pselect6_time64(struct thread *td,
     struct linux_pselect6_time64_args *args)
 {
 	struct l_timespec64 lts;
 	struct timespec ts, *tsp;
 	int error;
 
 	if (args->tsp != NULL) {
 		error = copyin(args->tsp, &lts, sizeof(lts));
 		if (error != 0)
 			return (error);
 		error = linux_to_native_timespec64(&ts, &lts);
 		if (error != 0)
 			return (error);
 		tsp = &ts;
 	} else
 		tsp = NULL;
 
 	error = linux_common_pselect6(td, args->nfds, args->readfds,
 	    args->writefds, args->exceptfds, tsp, args->sig);
 	if (error != 0)
 		return (error);
 
 	if (args->tsp != NULL) {
 		error = native_to_linux_timespec64(&lts, tsp);
 		if (error == 0)
 			error = copyout(&lts, args->tsp, sizeof(lts));
 	}
 	return (error);
 }
 #endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
 
 int
 linux_ppoll(struct thread *td, struct linux_ppoll_args *args)
 {
 	struct timespec uts, *tsp;
 	struct l_timespec lts;
 	int error;
 
 	if (args->tsp != NULL) {
 		error = copyin(args->tsp, &lts, sizeof(lts));
 		if (error)
 			return (error);
 		error = linux_to_native_timespec(&uts, &lts);
 		if (error != 0)
 			return (error);
 		tsp = &uts;
 	} else
 		tsp = NULL;
 
 	error = linux_common_ppoll(td, args->fds, args->nfds, tsp,
 	    args->sset, args->ssize);
 	if (error != 0)
 		return (error);
 	if (tsp != NULL) {
 		error = native_to_linux_timespec(&lts, tsp);
 		if (error == 0)
 			error = copyout(&lts, args->tsp, sizeof(lts));
 	}
 	return (error);
 }
 
 static int
 linux_common_ppoll(struct thread *td, struct pollfd *fds, uint32_t nfds,
     struct timespec *tsp, l_sigset_t *sset, l_size_t ssize)
 {
 	struct timespec ts0, ts1;
 	struct pollfd stackfds[32];
 	struct pollfd *kfds;
  	l_sigset_t l_ss;
  	sigset_t *ssp;
  	sigset_t ss;
  	int error;
 
 	if (kern_poll_maxfds(nfds))
 		return (EINVAL);
 	if (sset != NULL) {
 		if (ssize != sizeof(l_ss))
 			return (EINVAL);
 		error = copyin(sset, &l_ss, sizeof(l_ss));
 		if (error)
 			return (error);
 		linux_to_bsd_sigset(&l_ss, &ss);
 		ssp = &ss;
 	} else
 		ssp = NULL;
 	if (tsp != NULL)
 		nanotime(&ts0);
 
 	if (nfds > nitems(stackfds))
 		kfds = mallocarray(nfds, sizeof(*kfds), M_TEMP, M_WAITOK);
 	else
 		kfds = stackfds;
 	error = linux_pollin(td, kfds, fds, nfds);
 	if (error != 0)
 		goto out;
 
 	error = kern_poll_kfds(td, kfds, nfds, tsp, ssp);
 	if (error == 0)
 		error = linux_pollout(td, kfds, fds, nfds);
 
 	if (error == 0 && tsp != NULL) {
 		if (td->td_retval[0]) {
 			nanotime(&ts1);
 			timespecsub(&ts1, &ts0, &ts1);
 			timespecsub(tsp, &ts1, tsp);
 			if (tsp->tv_sec < 0)
 				timespecclear(tsp);
 		} else
 			timespecclear(tsp);
 	}
 
 out:
 	if (nfds > nitems(stackfds))
 		free(kfds, M_TEMP);
 	return (error);
 }
 
 #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
 int
 linux_ppoll_time64(struct thread *td, struct linux_ppoll_time64_args *args)
 {
 	struct timespec uts, *tsp;
 	struct l_timespec64 lts;
 	int error;
 
 	if (args->tsp != NULL) {
 		error = copyin(args->tsp, &lts, sizeof(lts));
 		if (error != 0)
 			return (error);
 		error = linux_to_native_timespec64(&uts, &lts);
 		if (error != 0)
 			return (error);
 		tsp = &uts;
 	} else
  		tsp = NULL;
 	error = linux_common_ppoll(td, args->fds, args->nfds, tsp,
 	    args->sset, args->ssize);
 	if (error != 0)
 		return (error);
 	if (tsp != NULL) {
 		error = native_to_linux_timespec64(&lts, tsp);
 		if (error == 0)
 			error = copyout(&lts, args->tsp, sizeof(lts));
 	}
 	return (error);
 }
 #endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
 
 static int
 linux_pollin(struct thread *td, struct pollfd *fds, struct pollfd *ufds, u_int nfd)
 {
 	int error;
 	u_int i;
 
 	error = copyin(ufds, fds, nfd * sizeof(*fds));
 	if (error != 0)
 		return (error);
 
 	for (i = 0; i < nfd; i++) {
 		if (fds->events != 0)
 			linux_to_bsd_poll_events(td, fds->fd,
 			    fds->events, &fds->events);
 		fds++;
 	}
 	return (0);
 }
 
 static int
 linux_pollout(struct thread *td, struct pollfd *fds, struct pollfd *ufds, u_int nfd)
 {
 	int error = 0;
 	u_int i, n = 0;
 
 	for (i = 0; i < nfd; i++) {
 		if (fds->revents != 0) {
 			bsd_to_linux_poll_events(fds->revents,
 			    &fds->revents);
 			n++;
 		}
 		error = copyout(&fds->revents, &ufds->revents,
 		    sizeof(ufds->revents));
 		if (error)
 			return (error);
 		fds++;
 		ufds++;
 	}
 	td->td_retval[0] = n;
 	return (0);
 }
 
 int
 linux_sched_rr_get_interval(struct thread *td,
     struct linux_sched_rr_get_interval_args *uap)
 {
 	struct timespec ts;
 	struct l_timespec lts;
 	struct thread *tdt;
 	int error;
 
 	/*
 	 * According to man in case the invalid pid specified
 	 * EINVAL should be returned.
 	 */
 	if (uap->pid < 0)
 		return (EINVAL);
 
 	tdt = linux_tdfind(td, uap->pid, -1);
 	if (tdt == NULL)
 		return (ESRCH);
 
 	error = kern_sched_rr_get_interval_td(td, tdt, &ts);
 	PROC_UNLOCK(tdt->td_proc);
 	if (error != 0)
 		return (error);
 	error = native_to_linux_timespec(&lts, &ts);
 	if (error != 0)
 		return (error);
 	return (copyout(&lts, uap->interval, sizeof(lts)));
 }
 
 /*
  * In case when the Linux thread is the initial thread in
  * the thread group thread id is equal to the process id.
  * Glibc depends on this magic (assert in pthread_getattr_np.c).
  */
 struct thread *
 linux_tdfind(struct thread *td, lwpid_t tid, pid_t pid)
 {
 	struct linux_emuldata *em;
 	struct thread *tdt;
 	struct proc *p;
 
 	tdt = NULL;
 	if (tid == 0 || tid == td->td_tid) {
 		tdt = td;
 		PROC_LOCK(tdt->td_proc);
 	} else if (tid > PID_MAX)
 		tdt = tdfind(tid, pid);
 	else {
 		/*
 		 * Initial thread where the tid equal to the pid.
 		 */
 		p = pfind(tid);
 		if (p != NULL) {
 			if (SV_PROC_ABI(p) != SV_ABI_LINUX) {
 				/*
 				 * p is not a Linuxulator process.
 				 */
 				PROC_UNLOCK(p);
 				return (NULL);
 			}
 			FOREACH_THREAD_IN_PROC(p, tdt) {
 				em = em_find(tdt);
 				if (tid == em->em_tid)
 					return (tdt);
 			}
 			PROC_UNLOCK(p);
 		}
 		return (NULL);
 	}
 
 	return (tdt);
 }
 
 void
 linux_to_bsd_waitopts(int options, int *bsdopts)
 {
 
 	if (options & LINUX_WNOHANG)
 		*bsdopts |= WNOHANG;
 	if (options & LINUX_WUNTRACED)
 		*bsdopts |= WUNTRACED;
 	if (options & LINUX_WEXITED)
 		*bsdopts |= WEXITED;
 	if (options & LINUX_WCONTINUED)
 		*bsdopts |= WCONTINUED;
 	if (options & LINUX_WNOWAIT)
 		*bsdopts |= WNOWAIT;
 
 	if (options & __WCLONE)
 		*bsdopts |= WLINUXCLONE;
 }
 
 int
 linux_getrandom(struct thread *td, struct linux_getrandom_args *args)
 {
 	struct uio uio;
 	struct iovec iov;
 	int error;
 
 	if (args->flags & ~(LINUX_GRND_NONBLOCK|LINUX_GRND_RANDOM))
 		return (EINVAL);
 	if (args->count > INT_MAX)
 		args->count = INT_MAX;
 
 	iov.iov_base = args->buf;
 	iov.iov_len = args->count;
 
 	uio.uio_iov = &iov;
 	uio.uio_iovcnt = 1;
 	uio.uio_resid = iov.iov_len;
 	uio.uio_segflg = UIO_USERSPACE;
 	uio.uio_rw = UIO_READ;
 	uio.uio_td = td;
 
 	error = read_random_uio(&uio, args->flags & LINUX_GRND_NONBLOCK);
 	if (error == 0)
 		td->td_retval[0] = args->count - uio.uio_resid;
 	return (error);
 }
 
 int
 linux_mincore(struct thread *td, struct linux_mincore_args *args)
 {
 
 	/* Needs to be page-aligned */
 	if (args->start & PAGE_MASK)
 		return (EINVAL);
 	return (kern_mincore(td, args->start, args->len, args->vec));
 }
 
 #define	SYSLOG_TAG	"<6>"
 
 int
 linux_syslog(struct thread *td, struct linux_syslog_args *args)
 {
 	char buf[128], *src, *dst;
 	u_int seq;
 	int buflen, error;
 
 	if (args->type != LINUX_SYSLOG_ACTION_READ_ALL) {
 		linux_msg(td, "syslog unsupported type 0x%x", args->type);
 		return (EINVAL);
 	}
 
 	if (args->len < 6) {
 		td->td_retval[0] = 0;
 		return (0);
 	}
 
 	error = priv_check(td, PRIV_MSGBUF);
 	if (error)
 		return (error);
 
 	mtx_lock(&msgbuf_lock);
 	msgbuf_peekbytes(msgbufp, NULL, 0, &seq);
 	mtx_unlock(&msgbuf_lock);
 
 	dst = args->buf;
 	error = copyout(&SYSLOG_TAG, dst, sizeof(SYSLOG_TAG));
 	/* The -1 is to skip the trailing '\0'. */
 	dst += sizeof(SYSLOG_TAG) - 1;
 
 	while (error == 0) {
 		mtx_lock(&msgbuf_lock);
 		buflen = msgbuf_peekbytes(msgbufp, buf, sizeof(buf), &seq);
 		mtx_unlock(&msgbuf_lock);
 
 		if (buflen == 0)
 			break;
 
 		for (src = buf; src < buf + buflen && error == 0; src++) {
 			if (*src == '\0')
 				continue;
 
 			if (dst >= args->buf + args->len)
 				goto out;
 
 			error = copyout(src, dst, 1);
 			dst++;
 
 			if (*src == '\n' && *(src + 1) != '<' &&
 			    dst + sizeof(SYSLOG_TAG) < args->buf + args->len) {
 				error = copyout(&SYSLOG_TAG,
 				    dst, sizeof(SYSLOG_TAG));
 				dst += sizeof(SYSLOG_TAG) - 1;
 			}
 		}
 	}
 out:
 	td->td_retval[0] = dst - args->buf;
 	return (error);
 }
 
 int
 linux_getcpu(struct thread *td, struct linux_getcpu_args *args)
 {
 	int cpu, error, node;
 
 	cpu = td->td_oncpu; /* Make sure it doesn't change during copyout(9) */
 	error = 0;
 	node = cpuid_to_pcpu[cpu]->pc_domain;
 
 	if (args->cpu != NULL)
 		error = copyout(&cpu, args->cpu, sizeof(l_int));
 	if (args->node != NULL)
 		error = copyout(&node, args->node, sizeof(l_int));
 	return (error);
 }
+
+#if defined(__i386__) || defined(__amd64__)
+int
+linux_poll(struct thread *td, struct linux_poll_args *args)
+{
+	struct timespec ts, *tsp;
+
+	if (args->timeout != INFTIM) {
+		if (args->timeout < 0)
+			return (EINVAL);
+		ts.tv_sec = args->timeout / 1000;
+		ts.tv_nsec = (args->timeout % 1000) * 1000000;
+		tsp = &ts;
+	} else
+		tsp = NULL;
+
+	return (linux_common_ppoll(td, args->fds, args->nfds,
+	    tsp, NULL, 0));
+}
+#endif /* __i386__ || __amd64__ */
diff --git a/sys/i386/linux/syscalls.master b/sys/i386/linux/syscalls.master
index f75b1253bc14..acbe5628e7ce 100644
--- a/sys/i386/linux/syscalls.master
+++ b/sys/i386/linux/syscalls.master
@@ -1,2530 +1,2530 @@
  $FreeBSD$
 
 ;	@(#)syscalls.master	8.1 (Berkeley) 7/19/93
 ; System call name/number master file (or rather, slave, from LINUX).
 ; Processed to create linux_sysent.c, linux_proto.h and linux_syscall.h.
 
 ; Columns: number audit type nargs name alt{name,tag,rtyp}/comments
 ;	number	system call number, must be in order
 ;	audit	the audit event associated with the system call
 ;		A value of AUE_NULL means no auditing, but it also means that
 ;		there is no audit event for the call at this time. For the
 ;		case where the event exists, but we don't want auditing, the
 ;		event should be #defined to AUE_NULL in audit_kevents.h.
 ;	type	one of STD, NOPROTO, UNIMPL
 ;	name	pseudo-prototype of syscall routine
 ;		If one of the following alts is different, then all appear:
 ;	altname	name of system call if different
 ;	alttag	name of args struct tag if different from [o]`name'"_args"
 ;	altrtyp	return type if not int (bogus - syscalls always return int)
 ;		for UNIMPL, name continues with comments
 
 ; types:
 ;	STD	always included
 ;	UNIMPL	not implemented, placeholder only
 ;	NOPROTO	same as STD except do not create structure or
 ;		function prototype in sys/sysproto.h.  Does add a
 ;		definition to syscall.h besides adding a sysent.
 
 #include <sys/param.h>
 #include <sys/sysent.h>
 #include <sys/sysproto.h>
 #include <compat/linux/linux_sysproto.h>
 #include <i386/linux/linux.h>
 #include <i386/linux/linux_proto.h>
 
 ; Isn't pretty, but there seems to be no other way to trap nosys
 #define	nosys	linux_nosys
 
 ; #ifdef's, etc. may be included, and are copied to the output files.
 
 0	AUE_NULL	UNIMPL	setup
 1	AUE_EXIT	STD {
 		void linux_exit(
 		    int rval
 		);
 	}
 2	AUE_FORK	STD {
 		int linux_fork(void);
 	}
 3	AUE_NULL	NOPROTO {
 		int read(
 		    int fd,
 		    char *buf,
 		    u_int nbyte
 		);
 	}
 4	AUE_NULL	NOPROTO {
 		int write(
 		    int fd,
 		    char *buf,
 		    u_int nbyte
 		);
 	}
 5	AUE_OPEN_RWTC	STD {
 		int linux_open(
 		    char *path,
 		    l_int flags,
 		    l_int mode
 		);
 	}
 6	AUE_CLOSE	NOPROTO {
 		int close(
 		    int fd
 		);
 	}
 7	AUE_WAIT4	STD {
 		int linux_waitpid(
 		    l_pid_t pid,
 		    l_int *status,
 		    l_int options
 		);
 	}
 8	AUE_CREAT	STD {
 		int linux_creat(
 		    char *path,
 		    l_int mode
 		);
 	}
 9	AUE_LINK	STD {
 		int linux_link(
 		    char *path,
 		    char *to
 		);
 	}
 10	AUE_UNLINK	STD {
 		int linux_unlink(
 		    char *path
 		);
 	}
 11	AUE_EXECVE	STD {
 		int linux_execve(
 		    char *path,
 		    char **argp,
 		    char **envp
 		);
 	}
 12	AUE_CHDIR	STD {
 		int linux_chdir(
 		    char *path
 		);
 	}
 13	AUE_NULL	STD {
 		int linux_time(
 		    l_time_t *tm
 		);
 	}
 14	AUE_MKNOD	STD {
 		int linux_mknod(
 		    char *path,
 		    l_int mode,
 		    l_dev_t dev
 		);
 	}
 15	AUE_CHMOD	STD {
 		int linux_chmod(
 		    char *path,
 		    l_mode_t mode
 		);
 	}
 16	AUE_LCHOWN	STD {
 		int linux_lchown16(
 		    char *path,
 		    l_uid16_t uid,
 		    l_gid16_t gid
 		);
 	}
 17	AUE_NULL	UNIMPL	break
 18	AUE_STAT	STD {
 		int linux_stat(
 		    char *path,
 		    struct linux_stat *up
 		);
 	}
 19	AUE_LSEEK	STD {
 		int linux_lseek(
 		    l_uint fdes,
 		    l_off_t off,
 		    l_int whence
 		);
 	}
 20	AUE_GETPID	STD {
 		int linux_getpid(void);
 	}
 21	AUE_MOUNT	STD {
 		int linux_mount(
 		    char *specialfile,
 		    char *dir,
 		    char *filesystemtype,
 		    l_ulong rwflag,
 		    void *data
 		);
 	}
 22	AUE_UMOUNT	STD {
 		int linux_oldumount(
 		    char *path
 		);
 	}
 23	AUE_SETUID	STD {
 		int linux_setuid16(
 		    l_uid16_t uid
 		);
 	}
 24	AUE_GETUID	STD {
 		int linux_getuid16(void);
 	}
 25	AUE_SETTIMEOFDAY	STD {
 		int linux_stime(void);
 	}
 26	AUE_PTRACE	STD {
 		int linux_ptrace(
 		    l_long req,
 		    l_long pid,
 		    l_long addr,
 		    l_long data
 		);
 	}
 27	AUE_NULL	STD {
 		int linux_alarm(
 		    l_uint secs
 		);
 	}
 28	AUE_FSTAT	STD {
 		int linux_fstat(
 		    l_uint fd,
 		    struct linux_stat *up
 		);
 	}
 29	AUE_NULL	STD {
 		int linux_pause(void);
 	}
 30	AUE_UTIME	STD {
 		int linux_utime(
 		    char *fname,
 		    struct l_utimbuf *times
 		);
 	}
 31	AUE_NULL	UNIMPL	stty
 32	AUE_NULL	UNIMPL	gtty
 33	AUE_ACCESS	STD {
 		int linux_access(
 		    char *path,
 		    l_int amode
 		);
 	}
 34	AUE_NICE	STD {
 		int linux_nice(
 		    l_int inc
 		);
 	}
 35	AUE_NULL	UNIMPL	ftime
 36	AUE_SYNC	NOPROTO {
 		int sync(void);
 	}
 37	AUE_KILL	STD {
 		int linux_kill(
 		    l_int pid,
 		    l_int signum
 		);
 	}
 38	AUE_RENAME	STD {
 		int linux_rename(
 		    char *from,
 		    char *to
 		);
 	}
 39	AUE_MKDIR	STD {
 		int linux_mkdir(
 		    char *path,
 		    l_int mode
 		);
 	}
 40	AUE_RMDIR	STD {
 		int linux_rmdir(
 		    char *path
 		);
 	}
 41	AUE_DUP		NOPROTO {
 		int dup(
 		    u_int fd
 		);
 	}
 42	AUE_PIPE	STD {
 		int linux_pipe(
 		    l_int *pipefds
 		);
 	}
 43	AUE_NULL	STD {
 		int linux_times(
 		    struct l_times_argv *buf
 		);
 	}
 44	AUE_NULL	UNIMPL	prof
 45	AUE_NULL	STD {
 		int linux_brk(
 		    l_ulong dsend
 		);
 	}
 46	AUE_SETGID	STD {
 		int linux_setgid16(
 		    l_gid16_t gid
 		);
 	}
 47	AUE_GETGID	STD {
 		int linux_getgid16(void);
 	}
 48	AUE_NULL	STD {
 		int linux_signal(
 		    l_int sig,
 		    void *handler
 		);
 	}
 49	AUE_GETEUID	STD {
 		int linux_geteuid16(void);
 	}
 50	AUE_GETEGID	STD {
 		int linux_getegid16(void);
 	}
 51	AUE_ACCT	NOPROTO {
 		int acct(
 		    char *path
 		);
 	}
 52	AUE_UMOUNT	STD {
 		int linux_umount(
 		    char *path,
 		    l_int flags
 		);
 	}
 53	AUE_NULL	UNIMPL	lock
 54	AUE_IOCTL	STD {
 		int linux_ioctl(
 		    l_uint fd,
 		    l_uint cmd,
 		    l_ulong arg
 		);
 	}
 55	AUE_FCNTL	STD {
 		int linux_fcntl(
 		    l_uint fd,
 		    l_uint cmd,
 		    l_ulong arg
 		);
 	}
 56	AUE_NULL	UNIMPL	mpx
 57	AUE_SETPGRP	NOPROTO {
 		int setpgid(
 		    int pid,
 		    int pgid
 		);
 	}
 58	AUE_NULL	UNIMPL	ulimit
 59	AUE_NULL	STD {
 		int linux_olduname(void);
 	}
 60	AUE_UMASK	NOPROTO {
 		int umask(
 		    int newmask
 		);
 	}
 61	AUE_CHROOT	NOPROTO {
 		int chroot(
 		    char *path
 		);
 	}
 62	AUE_NULL	STD {
 		int linux_ustat(
 		    l_dev_t dev,
 		    struct l_ustat *ubuf
 		);
 	}
 63	AUE_DUP2	NOPROTO {
 		int dup2(
 		    u_int from,
 		    u_int to
 		);
 	}
 64	AUE_GETPPID	STD {
 		int linux_getppid(void);
 	}
 65	AUE_GETPGRP	NOPROTO {
 		int getpgrp(void);
 	}
 66	AUE_SETSID	NOPROTO {
 		int setsid(void);
 	}
 67	AUE_NULL	STD {
 		int linux_sigaction(
 		    l_int sig,
 		    l_osigaction_t *nsa,
 		    l_osigaction_t *osa
 		);
 	}
 68	AUE_NULL	STD {
 		int linux_sgetmask(void);
 	}
 69	AUE_NULL	STD {
 		int linux_ssetmask(
 		    l_osigset_t mask
 		);
 	}
 70	AUE_SETREUID	STD {
 		int linux_setreuid16(
 		    l_uid16_t ruid,
 		    l_uid16_t euid
 		);
 	}
 71	AUE_SETREGID	STD {
 		int linux_setregid16(
 		    l_gid16_t rgid,
 		    l_gid16_t egid
 		);
 	}
 72	AUE_NULL	STD {
 		int linux_sigsuspend(
 		    l_int hist0,
 		    l_int hist1,
 		    l_osigset_t mask
 		);
 	}
 73	AUE_NULL	STD {
 		int linux_sigpending(
 		    l_osigset_t *mask
 		);
 	}
 74	AUE_SYSCTL	STD {
 		int linux_sethostname(
 		    char *hostname,
 		    u_int len
 		);
 	}
 75	AUE_SETRLIMIT	STD {
 		int linux_setrlimit(
 		    l_uint resource,
 		    struct l_rlimit *rlim
 		);
 	}
 76	AUE_GETRLIMIT	STD {
 		int linux_old_getrlimit(
 		    l_uint resource,
 		    struct l_rlimit *rlim
 		);
 	}
 77	AUE_GETRUSAGE	NOPROTO {
 		int getrusage(
 		    int who,
 		    struct rusage *rusage
 		);
 	}
 78	AUE_NULL	NOPROTO {
 		int gettimeofday(
 		    struct timeval *tp,
 		    struct timezone *tzp
 		);
 	}
 79	AUE_SETTIMEOFDAY	NOPROTO {
 		int settimeofday(
 		    struct timeval *tv,
 		    struct timezone *tzp
 		);
 	}
 80	AUE_GETGROUPS	STD {
 		int linux_getgroups16(
 		    l_uint gidsetsize,
 		    l_gid16_t *gidset
 		);
 	}
 81	AUE_SETGROUPS	STD {
 		int linux_setgroups16(
 		    l_uint gidsetsize,
 		    l_gid16_t *gidset
 		);
 	}
 82	AUE_SELECT	STD {
 		int linux_old_select(
 		    struct l_old_select_argv *ptr
 		);
 	}
 83	AUE_SYMLINK	STD {
 		int linux_symlink(
 		    char *path,
 		    char *to
 		);
 	}
 ; 84: oldlstat
 84	AUE_LSTAT	STD {
 		int linux_lstat(
 		    char *path,
 		    struct l_stat *up
 		);
 	}
 85	AUE_READLINK	STD {
 		int linux_readlink(
 		    char *name,
 		    char *buf,
 		    l_int count
 		);
 	}
 86	AUE_USELIB	STD {
 		int linux_uselib(
 		    char *library
 		);
 	}
 87	AUE_SWAPON	NOPROTO {
 		int swapon(
 		    char *name
 		);
 	}
 88	AUE_REBOOT	STD {
 		int linux_reboot(
 		    l_int magic1,
 		    l_int magic2,
 		    l_uint cmd,
 		    void *arg
 		);
 	}
 ; 89: old_readdir
 89	AUE_GETDIRENTRIES	STD  {
 		int linux_readdir(
 		    l_uint fd,
 		    struct l_dirent *dent,
 		    l_uint count
 		);
 	}
 ; 90: old_mmap
 90	AUE_MMAP	STD {
 		int linux_mmap(
 		    struct l_mmap_argv *ptr
 		);
 	}
 91	AUE_MUNMAP	NOPROTO {
 		int munmap(
 		    caddr_t addr,
 		    int len
 		);
 	}
 92	AUE_TRUNCATE	STD {
 		int linux_truncate(
 		    char *path,
 		    l_ulong length
 		);
 	}
 93	AUE_FTRUNCATE	STD {
 		int linux_ftruncate(
 		    int fd,
 		    long length
 		);
 	}
 94	AUE_FCHMOD	NOPROTO {
 		int fchmod(
 		    int fd,
 		    int mode
 		);
 	}
 95	AUE_FCHOWN	NOPROTO {
 		int fchown(
 		    int fd,
 		    int uid,
 		    int gid
 		);
 	}
 96	AUE_GETPRIORITY	STD {
 		int linux_getpriority(
 		    int which,
 		    int who
 		);
 	}
 97	AUE_SETPRIORITY	NOPROTO {
 		int setpriority(
 		    int which,
 		    int who,
 		    int prio
 		);
 	}
 98	AUE_PROFILE	UNIMPL	profil
 99	AUE_STATFS	STD {
 		int linux_statfs(
 		    char *path,
 		    struct l_statfs_buf *buf
 		);
 	}
 100	AUE_FSTATFS	STD {
 		int linux_fstatfs(
 		    l_uint fd,
 		    struct l_statfs_buf *buf
 		);
 	}
 101	AUE_NULL	STD {
 		int linux_ioperm(
 		    l_ulong start,
 		    l_ulong length,
 		    l_int enable
 		);
 	}
 102	AUE_NULL	STD {
 		int linux_socketcall(
 		    l_int what,
 		    l_ulong args
 		);
 	}
 103	AUE_NULL	STD {
 		int linux_syslog(
 		    l_int type,
 		    char *buf,
 		    l_int len
 		);
 	}
 104	AUE_SETITIMER	STD {
 		int linux_setitimer(
 		    l_int which,
 		    struct l_itimerval *itv,
 		    struct l_itimerval *oitv
 		);
 	}
 105	AUE_GETITIMER	STD {
 		int linux_getitimer(
 		    l_int which,
 		    struct l_itimerval *itv
 		);
 	}
 106	AUE_STAT	STD {
 		int linux_newstat(
 		    char *path,
 		    struct l_newstat *buf
 		);
 	}
 107	AUE_LSTAT	STD {
 		int linux_newlstat(
 		    char *path,
 		    struct l_newstat *buf
 		);
 	}
 108	AUE_FSTAT	STD {
 		int linux_newfstat(
 		    l_uint fd,
 		    struct l_newstat *buf
 		);
 	}
 ; 109: olduname
 109	AUE_NULL	STD {
 		int linux_uname(void);
 	}
 110	AUE_NULL	STD {
 		int linux_iopl(
 		    l_int level
 		);
 	}
 111	AUE_NULL	STD {
 		int linux_vhangup(void);
 	}
 112	AUE_NULL	UNIMPL	idle
 113	AUE_NULL	STD {
 		int linux_vm86old(void);
 	}
 114	AUE_WAIT4	STD {
 		int linux_wait4(
 		    l_pid_t pid,
 		    l_int *status,
 		    l_int options,
 		    void *rusage
 		);
 	}
 115	AUE_SWAPOFF	STD {
 		int linux_swapoff(void);
 	}
 116	AUE_NULL	STD {
 		int linux_sysinfo(
 		    struct l_sysinfo *info
 		);
 	}
 117	AUE_NULL	STD {
 		int linux_ipc(
 		    l_uint what,
 		    l_int arg1,
 		    l_int arg2,
 		    l_uint arg3,
 		    l_uintptr_t ptr,
 		    l_uint arg5
 		);
 	}
 118	AUE_FSYNC	NOPROTO {
 		int fsync(
 		    int fd
 		);
 	}
 119	AUE_SIGRETURN	STD {
 		int linux_sigreturn(
 		    struct l_sigframe *sfp
 		);
 	}
 120	AUE_RFORK	STD {
 		int linux_clone(
 		    l_int flags,
 		    void *stack,
 		    void *parent_tidptr,
 		    void *tls,
 		    void *child_tidptr
 		);
 	}
 121	AUE_SYSCTL	STD {
 		int linux_setdomainname(
 		    char *name,
 		    int len
 		);
 	}
 122	AUE_NULL	STD {
 		int linux_newuname(
 		    struct l_new_utsname *buf
 		);
 	}
 123	AUE_NULL	STD {
 		int linux_modify_ldt(
 		    l_int func,
 		    void *ptr,
 		    l_ulong bytecount
 		);
 	}
 124	AUE_ADJTIME	STD {
 		int linux_adjtimex(void);
 	}
 125	AUE_MPROTECT	STD {
 		int linux_mprotect(
 		    caddr_t addr,
 		    int len,
 		    int prot
 		);
 	}
 126	AUE_SIGPROCMASK	STD {
 		int linux_sigprocmask(
 		    l_int how,
 		    l_osigset_t *mask,
 		    l_osigset_t *omask
 		);
 	}
 127	AUE_NULL	UNIMPL	create_module
 128	AUE_NULL	STD {
 		int linux_init_module(void);
 	}
 129	AUE_NULL	STD {
 		int linux_delete_module(void);
 	}
 130	AUE_NULL	UNIMPL	get_kernel_syms
 131	AUE_QUOTACTL	STD {
 		int linux_quotactl(void);
 	}
 132	AUE_GETPGID	NOPROTO {
 		int getpgid(
 		    int pid
 		);
 	}
 133	AUE_FCHDIR	NOPROTO {
 		int fchdir(
 		    int fd
 		);
 	}
 134	AUE_BDFLUSH	STD {
 		int linux_bdflush(void);
 	}
 135	AUE_NULL	STD {
 		int linux_sysfs(
 		    l_int option,
 		    l_ulong arg1,
 		    l_ulong arg2
 		);
 	}
 136	AUE_PERSONALITY	STD {
 		int linux_personality(
 		    l_uint per
 		);
 	}
 137	AUE_NULL	UNIMPL	afs_syscall
 138	AUE_SETFSUID	STD {
 		int linux_setfsuid16(
 		    l_uid16_t uid
 		);
 	}
 139	AUE_SETFSGID	STD {
 		int linux_setfsgid16(
 		    l_gid16_t gid
 		);
 	}
 140	AUE_LSEEK	STD {
 		int linux_llseek(
 		    l_int fd,
 		    l_ulong ohigh,
 		    l_ulong olow,
 		    l_loff_t *res,
 		    l_uint whence
 		);
 	}
 141	AUE_GETDIRENTRIES	STD  {
 		int linux_getdents(
 		    l_uint fd,
 		    void *dent,
 		    l_uint count
 		);
 	}
 ; 142: newselect
 142	AUE_SELECT	STD {
 		int linux_select(
 		    l_int nfds,
 		    l_fd_set *readfds,
 		    l_fd_set *writefds,
 		    l_fd_set *exceptfds,
 		    struct l_timeval *timeout
 		);
 	}
 143	AUE_FLOCK	NOPROTO {
 		int flock(
 		    int fd,
 		    int how
 		);
 	}
 144	AUE_MSYNC	STD {
 		int linux_msync(
 		    l_ulong addr,
 		    l_size_t len,
 		    l_int fl
 		);
 	}
 145	AUE_READV	NOPROTO {
 		int readv(
 		    int fd,
 		    struct iovec *iovp,
 		    u_int iovcnt
 		);
 	}
 146	AUE_WRITEV	NOPROTO {
 		int writev(
 		    int fd,
 		    struct iovec *iovp,
 		    u_int iovcnt
 		);
 	}
 147	AUE_GETSID	STD {
 		int linux_getsid(
 		    l_pid_t pid
 		);
 	}
 148	AUE_NULL	STD {
 		int linux_fdatasync(
 		    l_uint fd
 		);
 	}
 149	AUE_SYSCTL	STD {
 		int linux_sysctl(
 		    struct l___sysctl_args *args
 		);
 	}
 150	AUE_MLOCK	NOPROTO {
 		int mlock(
 		    const void *addr,
 		    size_t len
 		);
 	}
 151	AUE_MUNLOCK	NOPROTO {
 		int munlock(
 		    const void *addr,
 		    size_t len
 		);
 	}
 152	AUE_MLOCKALL	NOPROTO {
 		int mlockall(
 		    int how
 		);
 	}
 153	AUE_MUNLOCKALL	NOPROTO {
 		int munlockall(void);
 	}
 154	AUE_SCHED_SETPARAM	STD {
 		int linux_sched_setparam(
 		    l_pid_t pid,
 		    struct sched_param *param
 		);
 	}
 155	AUE_SCHED_GETPARAM	STD {
 		int linux_sched_getparam(
 		    l_pid_t pid,
 		    struct sched_param *param
 		);
 	}
 156	AUE_SCHED_SETSCHEDULER	STD  {
 		int linux_sched_setscheduler(
 		    l_pid_t pid,
 		    l_int policy,
 		    struct sched_param *param
 		);
 	}
 157	AUE_SCHED_GETSCHEDULER	STD  {
 		int linux_sched_getscheduler(
 		    l_pid_t pid
 		);
 	}
 158	AUE_NULL	NOPROTO {
 		int sched_yield(void);
 	}
 159	AUE_SCHED_GET_PRIORITY_MAX	STD  {
 		int linux_sched_get_priority_max(
 		    l_int policy
 		);
 	}
 160	AUE_SCHED_GET_PRIORITY_MIN	STD  {
 		int linux_sched_get_priority_min(
 		    l_int policy
 		);
 	}
 161	AUE_SCHED_RR_GET_INTERVAL	STD {
 		int linux_sched_rr_get_interval(
 		    l_pid_t pid,
 		    struct l_timespec *interval
 		);
 	}
 162	AUE_NULL	STD {
 		int linux_nanosleep(
 		    const struct l_timespec *rqtp,
 		    struct l_timespec *rmtp
 		);
 	}
 163	AUE_NULL	STD {
 		int linux_mremap(
 		    l_ulong addr,
 		    l_ulong old_len,
 		    l_ulong new_len,
 		    l_ulong flags,
 		    l_ulong new_addr
 		);
 	}
 164	AUE_SETRESUID	STD {
 		int linux_setresuid16(
 		    l_uid16_t ruid,
 		    l_uid16_t euid,
 		    l_uid16_t suid
 		);
 	}
 165	AUE_GETRESUID	STD {
 		int linux_getresuid16(
 		    l_uid16_t *ruid,
 		    l_uid16_t *euid,
 		    l_uid16_t *suid
 		);
 	}
 166	AUE_NULL	STD {
 		int linux_vm86(void);
 	}
 167	AUE_NULL	UNIMPL	query_module
-168	AUE_POLL	NOPROTO {
-		int poll(
+168	AUE_POLL	STD {
+		int linux_poll(
 		    struct pollfd *fds,
 		    unsigned int nfds,
 		    long timeout
 		);
 	}
 169	AUE_NULL	UNIMPL	nfsservctl
 170	AUE_SETRESGID	STD {
 		int linux_setresgid16(
 		    l_gid16_t rgid,
 		    l_gid16_t egid,
 		    l_gid16_t sgid
 		);
 	}
 171	AUE_GETRESGID	STD {
 		int linux_getresgid16(
 		    l_gid16_t *rgid,
 		    l_gid16_t *egid,
 		    l_gid16_t *sgid
 		);
 	}
 172	AUE_PRCTL	STD {
 		int linux_prctl(
 		    l_int option,
 		    l_int arg2,
 		    l_int arg3,
 		    l_int arg4,
 		    l_int arg5
 		);
 	}
 173	AUE_NULL	STD {
 		int linux_rt_sigreturn(
 		    struct l_ucontext *ucp
 		);
 	}
 174	AUE_NULL	STD {
 		int linux_rt_sigaction(
 		    l_int sig,
 		    l_sigaction_t *act,
 		    l_sigaction_t *oact,
 		    l_size_t sigsetsize
 		);
 	}
 175	AUE_NULL	STD {
 		int linux_rt_sigprocmask(
 		    l_int how,
 		    l_sigset_t *mask,
 		    l_sigset_t *omask,
 		    l_size_t sigsetsize
 		);
 	}
 176	AUE_NULL	STD {
 		int linux_rt_sigpending(
 		    l_sigset_t *set,
 		    l_size_t sigsetsize
 		);
 	}
 177	AUE_NULL	STD {
 		int linux_rt_sigtimedwait(
 		    l_sigset_t *mask,
 		    l_siginfo_t *ptr,
 		    struct l_timespec *timeout,
 		    l_size_t sigsetsize
 		);
 	}
 178	AUE_NULL	STD {
 		int linux_rt_sigqueueinfo(
 		    l_pid_t pid,
 		    l_int sig,
 		    l_siginfo_t *info
 		);
 	}
 179	AUE_NULL	STD {
 		int linux_rt_sigsuspend(
 		    l_sigset_t *newset,
 		    l_size_t sigsetsize
 		);
 	}
 180	AUE_PREAD	STD {
 		int linux_pread(
 		    l_uint fd,
 		    char *buf,
 		    l_size_t nbyte,
 		    l_loff_t offset
 		);
 	}
 181	AUE_PWRITE	STD {
 		int linux_pwrite(
 		    l_uint fd,
 		    char *buf,
 		    l_size_t nbyte,
 		    l_loff_t offset
 		);
 	}
 182	AUE_CHOWN	STD {
 		int linux_chown16(
 		    char *path,
 		    l_uid16_t uid,
 		    l_gid16_t gid
 		);
 	}
 183	AUE_GETCWD	STD {
 		int linux_getcwd(
 		    char *buf,
 		    l_ulong bufsize
 		);
 	}
 184	AUE_CAPGET	STD {
 		int linux_capget(
 		    struct l_user_cap_header *hdrp,
 		    struct l_user_cap_data *datap
 		);
 	}
 185	AUE_CAPSET	STD {
 		int linux_capset(
 		    struct l_user_cap_header *hdrp,
 		    struct l_user_cap_data *datap
 		);
 	}
 186	AUE_NULL	STD {
 		int linux_sigaltstack(
 		    l_stack_t *uss,
 		    l_stack_t *uoss
 		);
 	}
 187	AUE_SENDFILE	STD {
 		int linux_sendfile(
 		    l_int out,
 		    l_int in,
 		    l_long *offset,
 		    l_size_t count
 		);
 	}
 188	AUE_GETPMSG	UNIMPL	getpmsg
 189	AUE_PUTPMSG	UNIMPL	putpmsg
 190	AUE_VFORK	STD {
 		int linux_vfork(void);
 	}
 ; 191: ugetrlimit
 191	AUE_GETRLIMIT	STD {
 		int linux_getrlimit(
 		    l_uint resource,
 		    struct l_rlimit *rlim
 		);
 	}
 192	AUE_MMAP	STD {
 		int linux_mmap2(
 		    l_ulong addr,
 		    l_ulong len,
 		    l_ulong prot,
 		    l_ulong flags,
 		    l_ulong fd,
 		    l_ulong pgoff
 		);
 	}
 193	AUE_TRUNCATE	STD {
 		int linux_truncate64(
 		    char *path,
 		    l_loff_t length
 		);
 	}
 194	AUE_FTRUNCATE	STD {
 		int linux_ftruncate64(
 		    l_uint fd,
 		    l_loff_t length
 		);
 	}
 195	AUE_STAT	STD {
 		int linux_stat64(
 		    const char *filename,
 		    struct l_stat64 *statbuf
 		);
 	}
 196	AUE_LSTAT	STD {
 		int linux_lstat64(
 		    const char *filename,
 		    struct l_stat64 *statbuf
 		);
 	}
 197	AUE_FSTAT	STD {
 		int linux_fstat64(
 		    l_int fd,
 		    struct l_stat64 *statbuf
 		);
 	}
 198	AUE_LCHOWN	STD {
 		int linux_lchown(
 		    char *path,
 		    l_uid_t uid,
 		    l_gid_t gid
 		);
 	}
 199	AUE_GETUID	STD {
 		int linux_getuid(void);
 	}
 200	AUE_GETGID	STD {
 		int linux_getgid(void);
 	}
 201	AUE_GETEUID	NOPROTO {
 		int geteuid(void);
 	}
 202	AUE_GETEGID	NOPROTO {
 		int getegid(void);
 	}
 203	AUE_SETREUID	NOPROTO {
 		int setreuid(
 		    uid_t ruid,
 		    uid_t euid
 		);
 	}
 204	AUE_SETREGID	NOPROTO {
 		int setregid(
 		    gid_t rgid,
 		    gid_t egid
 		);
 	}
 205	AUE_GETGROUPS	STD {
 		int linux_getgroups(
 		    l_int gidsetsize,
 		    l_gid_t *grouplist
 		);
 	}
 206	AUE_SETGROUPS	STD {
 		int linux_setgroups(
 		    l_int gidsetsize,
 		    l_gid_t *grouplist
 		);
 	}
 207	AUE_FCHOWN	NODEF	fchown fchown fchown_args int
 208	AUE_SETRESUID	NOPROTO {
 		int setresuid(
 		    uid_t ruid,
 		    uid_t euid,
 		    uid_t suid
 		);
 	}
 209	AUE_GETRESUID	NOPROTO {
 		int getresuid(
 		    uid_t *ruid,
 		    uid_t *euid,
 		    uid_t *suid
 		);
 	}
 210	AUE_SETRESGID	NOPROTO {
 		int setresgid(
 		    gid_t rgid,
 		    gid_t egid,
 		    gid_t sgid
 		);
 	}
 211	AUE_GETRESGID	NOPROTO {
 		int getresgid(
 		    gid_t *rgid,
 		    gid_t *egid,
 		    gid_t *sgid
 		);
 	}
 212	AUE_CHOWN	STD {
 		int linux_chown(
 		    char *path,
 		    l_uid_t uid,
 		    l_gid_t gid
 		);
 	}
 213	AUE_SETUID	NOPROTO {
 		int setuid(
 		    uid_t uid
 		);
 	}
 214	AUE_SETGID	NOPROTO {
 		int setgid(
 		    gid_t gid
 		);
 	}
 215	AUE_SETFSUID	STD {
 		int linux_setfsuid(
 		    l_uid_t uid
 		);
 	}
 216	AUE_SETFSGID	STD {
 		int linux_setfsgid(
 		    l_gid_t gid
 		);
 	}
 217	AUE_PIVOT_ROOT	STD {
 		int linux_pivot_root(
 		    char *new_root,
 		    char *put_old
 		);
 	}
 218	AUE_MINCORE	STD {
 		int linux_mincore(
 		    l_ulong start,
 		    l_size_t len,
 		    u_char *vec
 		);
 	}
 219	AUE_MADVISE	STD {
 		int linux_madvise(
 		    void *addr,
 		    size_t len,
 		    int behav
 		);
 	}
 220	AUE_GETDIRENTRIES	STD  {
 		int linux_getdents64(
 		    l_uint fd,
 		    void *dirent,
 		    l_uint count
 		);
 	}
 221	AUE_FCNTL	STD {
 		int linux_fcntl64(
 		    l_uint fd,
 		    l_uint cmd,
 		    l_ulong arg
 		);
 	}
 222	AUE_NULL	UNIMPL
 223	AUE_NULL	UNIMPL
 224	AUE_NULL	STD {
 		long linux_gettid(void);
 	}
 225	AUE_NULL	UNIMPL	linux_readahead
 226	AUE_NULL	STD {
 		int linux_setxattr(
 		    const char *path,
 		    const char *name,
 		    const char *value,
 		    l_size_t size,
 		    l_int flags
 		);
 	}
 227	AUE_NULL	STD {
 		int linux_lsetxattr(
 		    const char *path,
 		    const char *name,
 		    const char *value,
 		    l_size_t size,
 		    l_int flags
 		);
 	}
 228	AUE_NULL	STD {
 		int linux_fsetxattr(
 		    l_int fd,
 		    const char *name,
 		    const char *value,
 		    l_size_t size,
 		    l_int flags
 		);
 	}
 229	AUE_NULL	STD {
 		int linux_getxattr(
 		    const char *path,
 		    const char *name,
 		    char *value,
 		    l_size_t size
 		);
 	}
 230	AUE_NULL	STD {
 		int linux_lgetxattr(
 		    const char *path,
 		    const char *name,
 		    char *value,
 		    l_size_t size
 		);
 	}
 231	AUE_NULL	STD {
 		int linux_fgetxattr(
 		    l_int fd,
 		    const char *name,
 		    char *value,
 		    l_size_t size
 		);
 	}
 232	AUE_NULL	STD {
 		int linux_listxattr(
 		    const char *path,
 		    const char *list,
 		    l_size_t size
 		);
 	}
 233	AUE_NULL	STD {
 		int linux_llistxattr(
 		    const char *path,
 		    const char *list,
 		    l_size_t size
 		);
 	}
 234	AUE_NULL	STD {
 		int linux_flistxattr(
 		    l_int fd,
 		    const char *list,
 		    l_size_t size
 		);
 	}
 235	AUE_NULL	STD {
 		int linux_removexattr(
 		    const char *path,
 		    const char *name
 		);
 	}
 236	AUE_NULL	STD {
 		int linux_lremovexattr(
 		    const char *path,
 		    const char *name
 		);
 	}
 237	AUE_NULL	STD {
 		int linux_fremovexattr(
 		    l_int fd,
 		    const char *name
 		);
 	}
 238	AUE_NULL	STD {
 		int linux_tkill(
 		    int tid,
 		    int sig
 		);
 	}
 239	AUE_SENDFILE	STD {
 		int linux_sendfile64(
 		    l_int out,
 		    l_int in,
 		    l_loff_t *offset,
 		    l_size_t count
 		);
 	}
 240	AUE_NULL	STD {
 		int linux_sys_futex(
 		    uint32_t *uaddr,
 		    l_int op,
 		    uint32_t val,
 		    struct l_timespec *timeout,
 		    uint32_t *uaddr2,
 		    uint32_t val3
 		);
 	}
 241	AUE_NULL	STD {
 		int linux_sched_setaffinity(
 		    l_pid_t pid,
 		    l_uint len,
 		    l_ulong *user_mask_ptr
 		);
 	}
 242	AUE_NULL	STD {
 		int linux_sched_getaffinity(
 		    l_pid_t pid,
 		    l_uint len,
 		    l_ulong *user_mask_ptr
 		);
 	}
 243	AUE_NULL	STD {
 		int linux_set_thread_area(
 		    struct l_user_desc *desc
 		);
 	}
 244	AUE_NULL	STD {
 		int linux_get_thread_area(
 		    struct l_user_desc *desc
 		);
 	}
 245	AUE_NULL	UNIMPL	linux_io_setup
 246	AUE_NULL	UNIMPL	linux_io_destroy
 247	AUE_NULL	UNIMPL	linux_io_getevents
 248	AUE_NULL	UNIMPL	linux_io_submit
 249	AUE_NULL	UNIMPL	linux_io_cancel
 250	AUE_NULL	STD {
 		int linux_fadvise64(
 		    int fd,
 		    l_loff_t offset,
 		    l_size_t len,
 		    int advice
 		);
 	}
 251	AUE_NULL	UNIMPL
 252	AUE_EXIT	STD {
 		int linux_exit_group(
 		    int error_code
 		);
 	}
 253	AUE_NULL	STD {
 		int linux_lookup_dcookie(void);
 	}
 254	AUE_NULL	STD {
 		int linux_epoll_create(
 		    l_int size
 		);
 	}
 255	AUE_NULL	STD {
 		int linux_epoll_ctl(
 		    l_int epfd,
 		    l_int op,
 		    l_int fd,
 		    struct epoll_event *event
 		);
 	}
 256	AUE_NULL	STD {
 		int linux_epoll_wait(
 		    l_int epfd,
 		    struct epoll_event *events,
 		    l_int maxevents,
 		    l_int timeout
 		);
 	}
 257	AUE_NULL	STD {
 		int linux_remap_file_pages(void);
 	}
 258	AUE_NULL	STD {
 		int linux_set_tid_address(
 		    int *tidptr
 		);
 	}
 259	AUE_NULL	STD {
 		int linux_timer_create(
 		    clockid_t clock_id,
 		    struct sigevent *evp,
 		    l_timer_t *timerid
 		);
 	}
 260	AUE_NULL	STD {
 		int linux_timer_settime(
 		    l_timer_t timerid,
 		    l_int flags,
 		    const struct itimerspec *new,
 		    struct itimerspec *old
 		);
 	}
 261	AUE_NULL	STD {
 		int linux_timer_gettime(
 		    l_timer_t timerid,
 		    struct itimerspec *setting
 		);
 	}
 262	AUE_NULL	STD {
 		int linux_timer_getoverrun(
 		    l_timer_t timerid
 		);
 	}
 263	AUE_NULL	STD {
 		int linux_timer_delete(
 		    l_timer_t timerid
 		);
 	}
 264	AUE_CLOCK_SETTIME	STD {
 		int linux_clock_settime(
 		    clockid_t which,
 		    struct l_timespec *tp
 		);
 	}
 265	AUE_NULL	STD {
 		int linux_clock_gettime(
 		    clockid_t which,
 		    struct l_timespec *tp
 		);
 	}
 266	AUE_NULL	STD {
 		int linux_clock_getres(
 		    clockid_t which,
 		    struct l_timespec *tp
 		);
 	}
 267	AUE_NULL	STD {
 		int linux_clock_nanosleep(
 		    clockid_t which,
 		    int flags,
 		    struct l_timespec *rqtp,
 		    struct l_timespec *rmtp
 		);
 	}
 268	AUE_STATFS	STD {
 		int linux_statfs64(
 		    char *path,
 		    size_t bufsize,
 		    struct l_statfs64_buf *buf
 		);
 	}
 269	AUE_FSTATFS	STD {
 		int linux_fstatfs64(
 		    l_uint fd,
 		    size_t bufsize,
 		    struct l_statfs64_buf *buf
 		);
 	}
 270	AUE_NULL	STD {
 		int linux_tgkill(
 		    int tgid,
 		    int pid,
 		    int sig
 		);
 	}
 271	AUE_UTIMES	STD {
 		int linux_utimes(
 		    char *fname,
 		    struct l_timeval *tptr
 		);
 	}
 272	AUE_NULL	STD {
 		int linux_fadvise64_64(
 		    int fd,
 		    l_loff_t offset,
 		    l_loff_t len,
 		    int advice
 		);
 	}
 273	AUE_NULL	UNIMPL	vserver
 274	AUE_NULL	STD {
 		int linux_mbind(void);
 	}
 275	AUE_NULL	STD {
 		int linux_get_mempolicy(void);
 	}
 276	AUE_NULL	STD {
 		int linux_set_mempolicy(void);
 	}
 ; Linux 2.6.6:
 277	AUE_NULL	STD {
 		int linux_mq_open(
 		    const char *name,
 		    l_int oflag,
 		    l_mode_t mode,
 		    struct mq_attr *attr
 		);
 	}
 278	AUE_NULL	STD {
 		int linux_mq_unlink(
 		    const char *name
 		);
 	}
 279	AUE_NULL	STD {
 		int linux_mq_timedsend(
 		    l_mqd_t mqd,
 		    const char *msg_ptr,
 		    l_size_t msg_len,
 		    l_uint msg_prio,
 		    const struct l_timespec *abs_timeout
 		);
 	}
 280	AUE_NULL	STD {
 		int linux_mq_timedreceive(
 		    l_mqd_t mqd,
 		    char *msg_ptr,
 		    l_size_t msg_len,
 		    l_uint *msg_prio,
 		    const struct l_timespec *abs_timeout
 		);
 	}
 281	AUE_NULL	STD {
 		int linux_mq_notify(
 		    l_mqd_t mqd,
 		    const struct l_timespec *abs_timeout
 		);
 	}
 282	AUE_NULL	STD {
 		int linux_mq_getsetattr(
 		    l_mqd_t mqd,
 		    const struct mq_attr *attr,
 		    struct mq_attr *oattr
 		);
 	}
 283	AUE_NULL	STD {
 		int linux_kexec_load(void);
 	}
 284	AUE_WAIT6	STD {
 		int linux_waitid(
 		    int idtype,
 		    l_pid_t id,
 		    l_siginfo_t *info,
 		    int options,
 		    void *rusage
 		);
 	}
 285	AUE_NULL	UNIMPL
 ; Linux 2.6.11:
 286	AUE_NULL	STD {
 		int linux_add_key(void);
 	}
 287	AUE_NULL	STD {
 		int linux_request_key(void);
 	}
 288	AUE_NULL	STD {
 		int linux_keyctl(void);
 	}
 ; Linux 2.6.13:
 289	AUE_NULL	STD {
 		int linux_ioprio_set(void);
 	}
 290	AUE_NULL	STD {
 		int linux_ioprio_get(void);
 	}
 291	AUE_NULL	STD {
 		int linux_inotify_init(void);
 	}
 292	AUE_NULL	STD {
 		int linux_inotify_add_watch(void);
 	}
 293	AUE_NULL	STD {
 		int linux_inotify_rm_watch(void);
 	}
 ; Linux 2.6.16:
 294	AUE_NULL	STD {
 		int linux_migrate_pages(void);
 	}
 295	AUE_OPEN_RWTC	STD {
 		int linux_openat(
 		    l_int dfd,
 		    const char *filename,
 		    l_int flags,
 		    l_int mode
 		);
 	}
 296	AUE_MKDIRAT	STD {
 		int linux_mkdirat(
 		    l_int dfd,
 		    const char *pathname,
 		    l_int mode
 		);
 	}
 297	AUE_MKNODAT	STD {
 		int linux_mknodat(
 		    l_int dfd,
 		    const char *filename,
 		    l_int mode,
 		    l_uint dev
 		);
 	}
 298	AUE_FCHOWNAT	STD {
 		int linux_fchownat(
 		    l_int dfd,
 		    const char *filename,
 		    l_uid16_t uid,
 		    l_gid16_t gid,
 		    l_int flag
 		);
 	}
 299	AUE_FUTIMESAT	STD {
 		int linux_futimesat(
 		    l_int dfd,
 		    char *filename,
 		    struct l_timeval *utimes
 		);
 	}
 300	AUE_FSTATAT	STD {
 		int linux_fstatat64(
 		    l_int dfd,
 		    char *pathname,
 		    struct l_stat64 *statbuf,
 		    l_int flag
 		);
 	}
 301	AUE_UNLINKAT	STD {
 		int linux_unlinkat(
 		    l_int dfd,
 		    const char *pathname,
 		    l_int flag
 		);
 	}
 302	AUE_RENAMEAT	STD {
 		int linux_renameat(
 		    l_int olddfd,
 		    const char *oldname,
 		    l_int newdfd,
 		    const char *newname
 		);
 	}
 303	AUE_LINKAT	STD {
 		int linux_linkat(
 		    l_int olddfd,
 		    const char *oldname,
 		    l_int newdfd,
 		    const char *newname,
 		    l_int flag
 		);
 	}
 304	AUE_SYMLINKAT	STD {
 		int linux_symlinkat(
 		    const char *oldname,
 		    l_int newdfd,
 		    const char *newname
 		);
 	}
 305	AUE_READLINKAT	STD {
 		int linux_readlinkat(
 		    l_int dfd,
 		    const char *path,
 		    char *buf,
 		    l_int bufsiz
 		);
 	}
 306	AUE_FCHMODAT	STD {
 		int linux_fchmodat(
 		    l_int dfd,
 		    const char *filename,
 		    l_mode_t mode
 		);
 	}
 307	AUE_FACCESSAT	STD {
 		int linux_faccessat(
 		    l_int dfd,
 		    const char *filename,
 		    l_int amode
 		);
 	}
 308	AUE_SELECT	STD {
 		int linux_pselect6(
 		    l_int nfds,
 		    l_fd_set *readfds,
 		    l_fd_set *writefds,
 		    l_fd_set *exceptfds,
 		    struct l_timespec *tsp,
 		    l_uintptr_t *sig
 		);
 	}
 309	AUE_POLL	STD {
 		int linux_ppoll(
 		    struct pollfd *fds,
 		    uint32_t nfds,
 		    struct l_timespec *tsp,
 		    l_sigset_t *sset,
 		    l_size_t ssize
 		);
 	}
 310	AUE_NULL	STD {
 		int linux_unshare(void);
 	}
 ; Linux 2.6.17:
 311	AUE_NULL	STD {
 		int linux_set_robust_list(
 		    struct linux_robust_list_head *head,
 		    l_size_t len
 		);
 	}
 312	AUE_NULL	STD {
 		int linux_get_robust_list(
 		    l_int pid,
 		    struct linux_robust_list_head **head,
 		    l_size_t *len
 		);
 	}
 313	AUE_NULL	STD {
 		int linux_splice(
 		    int fd_in,
 		    l_loff_t *off_in,
 		    int fd_out,
 		    l_loff_t *off_out,
 		    l_size_t len,
 		    l_uint flags
 		);
 	}
 314	AUE_NULL	STD {
 		int linux_sync_file_range(
 		    l_int fd,
 		    l_loff_t offset,
 		    l_loff_t nbytes,
 		    unsigned int flags
 		);
 	}
 315	AUE_NULL	STD {
 		int linux_tee(void);
 	}
 316	AUE_NULL	STD {
 		int linux_vmsplice(void);
 	}
 ; Linux 2.6.18:
 317	AUE_NULL	STD {
 		int linux_move_pages(void);
 	}
 ; Linux 2.6.19:
 318	AUE_NULL	STD {
 		int linux_getcpu(
 		    l_uint *cpu,
 		    l_uint *node,
 		    void *cache
 		);
 	}
 319	AUE_NULL	STD {
 		int linux_epoll_pwait(
 		    l_int epfd,
 		    struct epoll_event *events,
 		    l_int maxevents,
 		    l_int timeout,
 		    l_sigset_t *mask,
 		    l_size_t sigsetsize
 		);
 	}
 ; Linux 2.6.22:
 320	AUE_FUTIMESAT	STD {
 		int linux_utimensat(
 		    l_int dfd,
 		    const char *pathname,
 		    const struct l_timespec *times,
 		    l_int flags
 		);
 	}
 321	AUE_NULL	STD {
 		int linux_signalfd(void);
 	}
 322	AUE_NULL	STD {
 		int linux_timerfd_create(
 		    l_int clockid,
 		    l_int flags
 		);
 	}
 323	AUE_NULL	STD {
 		int linux_eventfd(
 		    l_uint initval
 		);
 	}
 ; Linux 2.6.23:
 324	AUE_NULL	STD {
 		int linux_fallocate(
 		    l_int fd,
 		    l_int mode,
 		    l_loff_t offset,
 		    l_loff_t len
 		);
 	}
 ; Linux 2.6.25:
 325	AUE_NULL	STD {
 		int linux_timerfd_settime(
 		    l_int fd,
 		    l_int flags,
 		    const struct l_itimerspec *new_value,
 		    struct l_itimerspec *old_value
 		);
 	}
 326	AUE_NULL	STD {
 		int linux_timerfd_gettime(
 		    l_int fd,
 		    struct l_itimerspec *old_value
 		);
 	}
 ; Linux 2.6.27:
 327	AUE_NULL	STD {
 		int linux_signalfd4(void);
 	}
 328	AUE_NULL	STD {
 		int linux_eventfd2(
 		    l_uint initval,
 		    l_int flags
 		);
 	}
 329	AUE_NULL	STD {
 		int linux_epoll_create1(
 		    l_int flags
 		);
 	}
 330	AUE_NULL	STD {
 		int linux_dup3(
 		    l_int oldfd,
 		    l_int newfd,
 		    l_int flags
 		);
 	}
 331	AUE_NULL	STD {
 		int linux_pipe2(
 		    l_int *pipefds,
 		    l_int flags
 		);
 	}
 332	AUE_NULL	STD {
 		int linux_inotify_init1(void);
 	}
 ; Linux 2.6.30:
 333	AUE_NULL	STD {
 		int linux_preadv(
 		    l_ulong fd,
 		    struct iovec *vec,
 		    l_ulong vlen,
 		    l_ulong pos_l,
 		    l_ulong pos_h
 		);
 	}
 334	AUE_NULL	STD {
 		int linux_pwritev(
 		    l_ulong fd,
 		    struct iovec *vec,
 		    l_ulong vlen,
 		    l_ulong pos_l,
 		    l_ulong pos_h
 		);
 	}
 ; Linux 2.6.31:
 335	AUE_NULL	STD {
 		int linux_rt_tgsigqueueinfo(
 		    l_pid_t tgid,
 		    l_pid_t tid,
 		    l_int sig,
 		    l_siginfo_t *uinfo
 		);
 	}
 336	AUE_NULL	STD {
 		int linux_perf_event_open(void);
 	}
 ; Linux 2.6.33:
 337	AUE_NULL	STD {
 		int linux_recvmmsg(
 		    l_int s,
 		    struct l_mmsghdr *msg,
 		    l_uint vlen,
 		    l_uint flags,
 		    struct l_timespec *timeout
 		);
 	}
 338	AUE_NULL	STD {
 		int linux_fanotify_init(void);
 	}
 339	AUE_NULL	STD {
 		int linux_fanotify_mark(void);
 	}
 ; Linux 2.6.36:
 340	AUE_NULL	STD {
 		int linux_prlimit64(
 		    l_pid_t pid,
 		    l_uint resource,
 		    struct rlimit *new,
 		    struct rlimit *old
 		);
 	}
 ; Linux 2.6.39:
 341	AUE_NULL	STD {
 		int linux_name_to_handle_at(
 		    l_int dirfd,
 		    const char *name,
 		    struct l_file_handle *handle,
 		    l_int *mnt_id,
 		    l_int flags
 		);
 	}
 342	AUE_NULL	STD {
 		int linux_open_by_handle_at(
 		    l_int mountdirfd,
 		    struct l_file_handle *handle,
 		    l_int flags
 		);
 	}
 343	AUE_NULL	STD {
 		int linux_clock_adjtime(void);
 	}
 344	AUE_SYNC	STD {
 		int linux_syncfs(
 		    l_int fd
 		);
 	}
 ; Linux 3.0:
 345	AUE_NULL	STD {
 		int linux_sendmmsg(
 		    l_int s,
 		    struct l_mmsghdr *msg,
 		    l_uint vlen,
 		    l_uint flags
 		);
 	}
 346	AUE_NULL	STD {
 		int linux_setns(void);
 	}
 ; Linux 3.2 (glibc 2.15):
 347	AUE_NULL	STD {
 		int linux_process_vm_readv(
 		    l_pid_t pid,
 		    const struct iovec *lvec,
 		    l_ulong liovcnt,
 		    const struct iovec *rvec,
 		    l_ulong riovcnt,
 		    l_ulong flags
 		);
 	}
 348	AUE_NULL	STD {
 		int linux_process_vm_writev(
 		    l_pid_t pid,
 		    const struct iovec *lvec,
 		    l_ulong liovcnt,
 		    const struct iovec *rvec,
 		    l_ulong riovcnt,
 		    l_ulong flags
 		);
 	}
 ; Linux 3.5 (no glibc wrapper):
 349	AUE_NULL	STD {
 		int linux_kcmp(
 		    l_pid_t pid1,
 		    l_pid_t pid2,
 		    l_int type,
 		    l_ulong idx1,
 		    l_ulong idx
 		);
 	}
 ; Linux 3.8 (no glibc wrapper):
 350	AUE_NULL	STD {
 		int linux_finit_module(
 		    l_int fd,
 		    const char *uargs,
 		    l_int flags
 		);
 	}
 ; Linux 3.14:
 351	AUE_NULL	STD {
 		int linux_sched_setattr(
 		    l_pid_t pid,
 		    void *attr,
 		    l_uint flags
 		);
 	}
 352	AUE_NULL	STD {
 		int linux_sched_getattr(
 		    l_pid_t pid,
 		    void *attr,
 		    l_uint size,
 		    l_uint flags
 		);
 	}
 ; Linux 3.15:
 353	AUE_NULL	STD {
 		int linux_renameat2(
 		    l_int olddfd,
 		    const char *oldname,
 		    l_int newdfd,
 		    const char *newname,
 		    unsigned int flags
 		);
 	}
 ; Linux 3.17:
 354	AUE_NULL	STD {
 		int linux_seccomp(
 		    l_uint op,
 		    l_uint flags,
 		    const char *uargs
 		);
 	}
 355	AUE_NULL	STD {
 		int linux_getrandom(
 		    char *buf,
 		    l_size_t count,
 		    l_uint flags
 		);
 	}
 356	AUE_NULL	STD {
 		int linux_memfd_create(
 		    const char *uname_ptr,
 		    l_uint flags
 		);
 	}
 ; Linux 3.18:
 357	AUE_NULL	STD {
 		int linux_bpf(
 		    l_int cmd,
 		    void *attr,
 		    l_uint size
 		);
 	}
 ; Linux 3.19:
 358	AUE_NULL	STD {
 		int linux_execveat(
 		    l_int dfd,
 		    const char *filename,
 		    const char **argv,
 		    const char **envp,
 		    l_int flags
 		);
 	}
 ; Linux 4.3: sockets now direct system calls:
 359	AUE_SOCKET	STD {
 		int linux_socket(
 		    l_int domain,
 		    l_int type,
 		    l_int protocol
 		);
 	}
 360	AUE_SOCKETPAIR	STD {
 		int linux_socketpair(
 		    l_int domain,
 		    l_int type,
 		    l_int protocol,
 		    l_uintptr_t rsv
 		);
 	}
 361	AUE_BIND	STD {
 		int linux_bind(
 		    l_int s,
 		    l_uintptr_t name,
 		    l_int namelen
 		);
 	}
 362	AUE_CONNECT	STD {
 		int linux_connect(
 		    l_int s,
 		    l_uintptr_t name,
 		    l_int namelen
 		);
 	}
 363	AUE_LISTEN	STD {
 		int linux_listen(
 		    l_int s,
 		    l_int backlog
 		);
 	}
 364	AUE_ACCEPT	STD {
 		int linux_accept4(
 		    l_int s,
 		    l_uintptr_t addr,
 		    l_uintptr_t namelen,
 		    l_int flags
 		);
 	}
 365	AUE_GETSOCKOPT	STD {
 		int linux_getsockopt(
 		    l_int s,
 		    l_int level,
 		    l_int optname,
 		    l_uintptr_t optval,
 		    l_uintptr_t optlen
 		);
 	}
 366	AUE_SETSOCKOPT	STD {
 		int linux_setsockopt(
 		    l_int s,
 		    l_int level,
 		    l_int optname,
 		    l_uintptr_t optval,
 		    l_int optlen
 		);
 	}
 367	AUE_GETSOCKNAME	STD {
 		int linux_getsockname(
 		    l_int s,
 		    l_uintptr_t addr,
 		    l_uintptr_t namelen
 		);
 	}
 368	AUE_GETPEERNAME	STD {
 		int linux_getpeername(
 		    l_int s,
 		    l_uintptr_t addr,
 		    l_uintptr_t namelen
 		);
 	}
 369	AUE_SENDTO	STD {
 		int linux_sendto(
 		    l_int s,
 		    l_uintptr_t msg,
 		    l_int len,
 		    l_int flags,
 		    l_uintptr_t to,
 		    l_int tolen
 		);
 	}
 370	AUE_SENDMSG	STD {
 		int linux_sendmsg(
 		    l_int s,
 		    l_uintptr_t msg,
 		    l_int flags
 		);
 	}
 371	AUE_RECVFROM	STD {
 		int linux_recvfrom(
 		    l_int s,
 		    l_uintptr_t buf,
 		    l_size_t len,
 		    l_int flags,
 		    l_uintptr_t from,
 		    l_uintptr_t fromlen
 		);
 	}
 372	AUE_RECVMSG	STD {
 		int linux_recvmsg(
 		    l_int s,
 		    l_uintptr_t msg,
 		    l_int flags
 		);
 	}
 373	AUE_NULL	STD {
 		int linux_shutdown(
 		    l_int s,
 		    l_int how
 		);
 	}
 ; Linux 4.2:
 374	AUE_NULL	STD {
 		int linux_userfaultfd(
 		    l_int flags
 		);
 	}
 ; Linux 4.3:
 375	AUE_NULL	STD {
 		int linux_membarrier(
 		    l_int cmd,
 		    l_int flags
 		);
 	}
 ; Linux 4.4:
 376	AUE_NULL	STD {
 		int linux_mlock2(
 		    l_ulong start,
 		    l_size_t len,
 		    l_int flags
 		);
 	}
 ; Linux 4.5:
 377	AUE_NULL	STD {
 		int linux_copy_file_range(
 		    l_int fd_in,
 		    l_loff_t *off_in,
 		    l_int fd_out,
 		    l_loff_t *off_out,
 		    l_size_t len,
 		    l_uint flags
 		);
 	}
 ; Linux 4.6:
 378	AUE_NULL	STD {
 		int linux_preadv2(
 		    l_ulong fd,
 		    const struct iovec *vec,
 		    l_ulong vlen,
 		    l_ulong pos_l,
 		    l_ulong pos_h,
 		    l_int flags
 		);
 	}
 379	AUE_NULL	STD {
 		int linux_pwritev2(
 		    l_ulong fd,
 		    const struct iovec *vec,
 		    l_ulong vlen,
 		    l_ulong pos_l,
 		    l_ulong pos_h,
 		    l_int flags
 		);
 	}
 ; Linux 4.8:
 380	AUE_NULL	STD {
 		int linux_pkey_mprotect(
 		    l_ulong start,
 		    l_size_t len,
 		    l_ulong prot,
 		    l_int pkey
 		);
 	}
 381	AUE_NULL	STD {
 		int linux_pkey_alloc(
 		    l_ulong flags,
 		    l_ulong init_val
 		);
 	}
 382	AUE_NULL	STD {
 		int linux_pkey_free(
 		    l_int pkey
 		);
 	}
 ; Linux 4.11:
 383	AUE_NULL	STD {
 		int linux_statx(
 		    l_int dirfd,
 		    const char *pathname,
 		    l_uint flags,
 		    l_uint mask,
 		    void *statxbuf
 		);
 	}
 384	AUE_PRCTL	STD {
 		int linux_arch_prctl(
 		    l_int option,
 		    l_ulong arg2
 		);
 	}
 ; Linux 4.18:
 385	AUE_NULL	STD {
 		int linux_io_pgetevents(void);
 	}
 386	AUE_NULL	STD {
 		int linux_rseq(void);
 	}
 387-392	AUE_NULL	UNIMPL	nosys
 393	AUE_NULL	STD {
 		int linux_semget(
 		    l_key_t key,
 		    l_int nsems,
 		    l_int semflg
 		);
 	}
 394	AUE_NULL	STD {
 		int linux_semctl(
 		    l_int semid,
 		    l_int semnum,
 		    l_int cmd,
 		    union l_semun arg
 		);
 	}
 395	AUE_NULL	STD {
 		int linux_shmget(
 		    l_key_t key,
 		    l_size_t size,
 		    l_int shmflg
 		);
 	}
 396	AUE_NULL	STD {
 		int linux_shmctl(
 		    l_int shmid,
 		    l_int cmd,
 		    struct l_shmid_ds *buf
 		);
 	}
 397	AUE_NULL	STD {
 		int linux_shmat(
 		    l_int shmid,
 		    char *shmaddr,
 		    l_int shmflg
 		);
 	}
 398	AUE_NULL	STD {
 		int linux_shmdt(
 		    char *shmaddr
 		);
 	}
 399	AUE_NULL	STD {
 		int linux_msgget(
 		    l_key_t key,
 		    l_int msgflg
 		);
 	}
 400	AUE_NULL	STD {
 		int linux_msgsnd(
 		    l_int msqid,
 		    struct l_msgbuf *msgp,
 		    l_size_t msgsz,
 		    l_int msgflg
 		);
 	}
 401	AUE_NULL	STD {
 		int linux_msgrcv(
 		    l_int msqid,
 		    struct l_msgbuf *msgp,
 		    l_size_t msgsz,
 		    l_long msgtyp,
 		    l_int msgflg
 		);
 	}
 402	AUE_NULL	STD {
 		int linux_msgctl(
 		    l_int msqid,
 		    l_int cmd,
 		    struct l_msqid_ds *buf
 		);
 	}
 ; Linux 5.0:
 403	AUE_NULL	STD {
 		int linux_clock_gettime64(
 		    clockid_t which,
 		    struct l_timespec64 *tp
 		);
 	}
 404	AUE_NULL	STD {
 		int linux_clock_settime64(
 		    clockid_t which,
 		    struct l_timespec64 *tp
 		);
 	}
 405	AUE_NULL	STD {
 		int linux_clock_adjtime64(void);
 	}
 406	AUE_NULL	STD {
 		int linux_clock_getres_time64(
 		    clockid_t which,
 		    struct l_timespec64 *tp
 		);
 	}
 407	AUE_NULL	STD {
 		int linux_clock_nanosleep_time64(
 		    clockid_t which,
 		    l_int flags,
 		    struct l_timespec64 *rqtp,
 		    struct l_timespec64 *rmtp
 		);
 	}
 408	AUE_NULL	STD {
 		int linux_timer_gettime64(void);
 	}
 409	AUE_NULL	STD {
 		int linux_timer_settime64(void);
 	}
 410	AUE_NULL	STD {
 		int linux_timerfd_gettime64(void);
 	}
 411	AUE_NULL	STD {
 		int linux_timerfd_settime64(void);
 	}
 412	AUE_NULL	STD {
 		int linux_utimensat_time64(
 		    l_int dfd,
 		    const char *pathname,
 		    const struct l_timespec64 *times64,
 		    l_int flags
 		);
 	}
 413	AUE_NULL	STD {
 		int linux_pselect6_time64(
 		    l_int nfds,
 		    l_fd_set *readfds,
 		    l_fd_set *writefds,
 		    l_fd_set *exceptfds,
 		    struct l_timespec64 *tsp,
 		    l_uintptr_t *sig
 		);
 	}
 414	AUE_NULL	STD {
 		int linux_ppoll_time64(
 		    struct pollfd *fds,
 		    uint32_t nfds,
 		    struct l_timespec64 *tsp,
 		    l_sigset_t *sset,
 		    l_size_t ssize
 		);
 	}
 415	AUE_NULL	UNIMPL	nosys
 416	AUE_NULL	STD {
 		int linux_io_pgetevents_time64(void);
 	}
 417	AUE_NULL	STD {
 		int linux_recvmmsg_time64(void);
 	}
 418	AUE_NULL	STD {
 		int linux_mq_timedsend_time64(void);
 	}
 419	AUE_NULL	STD {
 		int linux_mq_timedreceive_time64(void);
 	}
 420	AUE_NULL	STD {
 		int linux_semtimedop_time64(void);
 	}
 421	AUE_NULL	STD {
 		int linux_rt_sigtimedwait_time64(
 		    l_sigset_t *mask,
 		    l_siginfo_t *ptr,
 		    struct l_timespec64 *timeout,
 		    l_size_t sigsetsize
 		);
 	}
 422	AUE_NULL	STD {
 		int linux_sys_futex_time64(
 		    uint32_t *uaddr,
 		    l_int op,
 		    uint32_t val,
 		    struct l_timespec64 *timeout,
 		    uint32_t *uaddr2,
 		    uint32_t val3
 		);
 	}
 423	AUE_NULL	STD {
 		int linux_sched_rr_get_interval_time64(void);
 	}
 424	AUE_NULL	STD {
 		int linux_pidfd_send_signal(
 		    l_int pidfd,
 		    l_int sig,
 		    l_siginfo_t *info,
 		    l_uint flags
 		);
 	}
 425	AUE_NULL	STD {
 		int linux_io_uring_setup(void);
 	}
 426	AUE_NULL	STD {
 		int linux_io_uring_enter(void);
 	}
 427	AUE_NULL	STD {
 		int linux_io_uring_register(void);
 	}
 428    AUE_NULL		STD {
 		int linux_open_tree(void);
 	}
 429    AUE_NULL		STD {
 		int linux_move_mount(void);
 	}
 430    AUE_NULL		STD {
 		int linux_fsopen(void);
 	}
 431    AUE_NULL		STD {
 		int linux_fsconfig(void);
 	}
 432    AUE_NULL		STD {
 		int linux_fsmount(void);
 	}
 433    AUE_NULL		STD {
 		int linux_fspick(void);
 	}
 434    AUE_NULL		STD {
 		int linux_pidfd_open(void);
 	}
 435    AUE_NULL		STD {
 		int linux_clone3(void);
 	}
 436    AUE_NULL		STD {
 		int linux_close_range(void);
 	}
 437    AUE_NULL		STD {
 		int linux_openat2(void);
 	}
 438    AUE_NULL		STD {
 		int linux_pidfd_getfd(void);
 	}
 439    AUE_NULL		STD {
 		int linux_faccessat2(void);
 	}
 440    AUE_NULL		STD {
 		int linux_process_madvise(void);
 	}
 441    AUE_NULL		STD {
 		int linux_epoll_pwait2(void);
 	}
 442    AUE_NULL		STD {
 		int linux_mount_setattr(void);
 	}
 ; please, keep this line at the end.
 443    AUE_NULL        UNIMPL  nosys
 ; vim: syntax=off